···

       
14
       
 
       
import { packageMetadata, version } from './packageMetadata';

     

       
15
       
 
       


     

       
16
       
 
       
const cwd = process.cwd();

     

       
17
       
-
       
const graphqlModule = path.join(cwd, 'node_modules/graphql/');

     

       
18
       
-
       
const virtualModule = path.join(cwd, 'virtual/');

     

       
19
       
-
       
const aliasModule = path.join(cwd, 'alias/');

     

       
20
       
 
       


     

       
21
       
 
       
const EXTERNAL = 'graphql';

     

       
22
       
 
       
const externalModules = ['dns', 'fs', 'path', 'url'];

     
···

       
65
       
 
       


     

       
66
       
 
       
export default {

     

       
67
       
 
       
  input: Object.keys(exports).reduce((input, key) => {

     

       
68
       
-
       
    input[key] = path.join('./virtual', key);

     

       
69
       
 
       
    return input;

     

       
70
       
 
       
  }, {}),

     

       
71
       
 
       
  external(id) {

     
···

       
80
       
 
       
    {

     

       
81
       
 
       
      async load(id) {

     

       
82
       
 
       
        if (!id.startsWith(virtualModule)) return null;

     

       
83
       
-
       
        const entry = path.relative(virtualModule, id).replace(/\.m?js$/, '');

     

       
0
       
 
       

     

       
0
       
 
       

     

       
84
       
 
       
        if (entry === 'version') return version;

     

       
85
       
 
       
        return exports[entry] || null;

     

       
86
       
 
       
      },

     
···

       
89
       
 
       
        if (!source.startsWith('.') && !source.startsWith('virtual/'))

     

       
90
       
 
       
          return null;

     

       
91
       
 
       


     

       
92
       
-
       
        const target = path.join(

     

       
93
       
-
       
          importer ? path.dirname(importer) : cwd,

     

       
94
       
 
       
          source

     

       
95
       
 
       
        );

     

       
96
       
 
       


     

       
97
       
-
       
        const virtualEntry = path.relative(virtualModule, target);

     

       
98
       
 
       
        if (!virtualEntry.startsWith('../')) {

     

       
99
       
-
       
          const aliasSource = path.join(aliasModule, virtualEntry);

     

       
100
       
 
       
          const alias = await this.resolve(aliasSource, undefined, {

     

       
101
       
 
       
            skipSelf: true,

     

       
102
       
 
       
          });

     

       
103
       
 
       
          return alias || target;

     

       
104
       
 
       
        }

     

       
105
       
 
       


     

       
106
       
-
       
        const graphqlEntry = path.relative(graphqlModule, target);

     

       
107
       
 
       
        if (!graphqlEntry.startsWith('../')) {

     

       
108
       
-
       
          const aliasSource = path.join(aliasModule, graphqlEntry);

     

       
109
       
 
       
          const alias = await this.resolve(aliasSource, undefined, {

     

       
110
       
 
       
            skipSelf: true,

     

       
111
       
 
       
          });

     

···

       
14
       
 
       
import { packageMetadata, version } from './packageMetadata';

     

       
15
       
 
       


     

       
16
       
 
       
const cwd = process.cwd();

     

       
17
       
+
       
const graphqlModule = path.posix.join(cwd, 'node_modules/graphql/');

     

       
18
       
+
       
const virtualModule = path.posix.join(cwd, 'virtual/');

     

       
19
       
+
       
const aliasModule = path.posix.join(cwd, 'alias/');

     

       
20
       
 
       


     

       
21
       
 
       
const EXTERNAL = 'graphql';

     

       
22
       
 
       
const externalModules = ['dns', 'fs', 'path', 'url'];

     
···

       
65
       
 
       


     

       
66
       
 
       
export default {

     

       
67
       
 
       
  input: Object.keys(exports).reduce((input, key) => {

     

       
68
       
+
       
    input[key] = path.posix.join('./virtual', key);

     

       
69
       
 
       
    return input;

     

       
70
       
 
       
  }, {}),

     

       
71
       
 
       
  external(id) {

     
···

       
80
       
 
       
    {

     

       
81
       
 
       
      async load(id) {

     

       
82
       
 
       
        if (!id.startsWith(virtualModule)) return null;

     

       
83
       
+
       
        const entry = path.posix

     

       
84
       
+
       
          .relative(virtualModule, id)

     

       
85
       
+
       
          .replace(/\.m?js$/, '');

     

       
86
       
 
       
        if (entry === 'version') return version;

     

       
87
       
 
       
        return exports[entry] || null;

     

       
88
       
 
       
      },

     
···

       
91
       
 
       
        if (!source.startsWith('.') && !source.startsWith('virtual/'))

     

       
92
       
 
       
          return null;

     

       
93
       
 
       


     

       
94
       
+
       
        const target = path.posix.join(

     

       
95
       
+
       
          importer ? path.posix.dirname(importer) : cwd,

     

       
96
       
 
       
          source

     

       
97
       
 
       
        );

     

       
98
       
 
       


     

       
99
       
+
       
        const virtualEntry = path.posix.relative(virtualModule, target);

     

       
100
       
 
       
        if (!virtualEntry.startsWith('../')) {

     

       
101
       
+
       
          const aliasSource = path.posix.join(aliasModule, virtualEntry);

     

       
102
       
 
       
          const alias = await this.resolve(aliasSource, undefined, {

     

       
103
       
 
       
            skipSelf: true,

     

       
104
       
 
       
          });

     

       
105
       
 
       
          return alias || target;

     

       
106
       
 
       
        }

     

       
107
       
 
       


     

       
108
       
+
       
        const graphqlEntry = path.posix.relative(graphqlModule, target);

     

       
109
       
 
       
        if (!graphqlEntry.startsWith('../')) {

     

       
110
       
+
       
          const aliasSource = path.posix.join(aliasModule, graphqlEntry);

     

       
111
       
 
       
          const alias = await this.resolve(aliasSource, undefined, {

     

       
112
       
 
       
            skipSelf: true,

     

       
113
       
 
       
          });