@quilted/rollup 0.1.2 → 0.1.4

package/source/graphql.ts

@@ -0,0 +1,139 @@
+import {dirname} from 'path';
+import {readFile, mkdir, writeFile} from 'fs/promises';
+
+import {parse, type DocumentNode} from 'graphql';
+import type {Plugin, TransformPluginContext} from 'rollup';
+
+import {
+  toGraphQLOperation,
+  cleanGraphQLDocument,
+  extractGraphQLImports,
+} from './graphql/transform.ts';
+
+export interface Options {
+  manifest?: string | boolean;
+}
+
+export function graphql({manifest}: Options = {}): Plugin {
+  const shouldWriteManifest = Boolean(manifest);
+  const manifestPath =
+    typeof manifest === 'string' ? manifest : `manifests/graphql.json`;
+
+  return {
+    name: '@quilted/graphql',
+    async transform(code, id) {
+      if (!id.endsWith('.graphql') && !id.endsWith('.gql')) return null;
+
+      const topLevelDefinitions = new Set<string>();
+
+      const loadedDocument = await loadDocument(
+        code,
+        id,
+        this,
+        (document, level) => {
+          if (level !== 0) return;
+
+          for (const definition of document.definitions) {
+            if ('name' in definition && definition.name != null) {
+              topLevelDefinitions.add(definition.name.value);
+            }
+          }
+        },
+      );
+
+      const document = toGraphQLOperation(
+        cleanGraphQLDocument(loadedDocument, {
+          removeUnused: {exclude: topLevelDefinitions},
+        }),
+      );
+
+      return {
+        code: `export default JSON.parse(${JSON.stringify(
+          JSON.stringify(document),
+        )})`,
+        meta: shouldWriteManifest
+          ? {
+              quilt: {graphql: document},
+            }
+          : undefined,
+      };
+    },
+    async generateBundle() {
+      if (!shouldWriteManifest) return;
+
+      const operations: Record<string, string> = {};
+
+      for (const moduleId of this.getModuleIds()) {
+        const operation = this.getModuleInfo(moduleId)?.meta?.quilt?.graphql;
+
+        if (
+          operation != null &&
+          typeof operation.id === 'string' &&
+          typeof operation.source === 'string'
+        ) {
+          operations[operation.id] = operation.source;
+        }
+      }
+
+      await mkdir(dirname(manifestPath), {recursive: true});
+      await writeFile(manifestPath, JSON.stringify(operations, null, 2));
+    },
+  };
+}
+
+async function loadDocument(
+  code: string,
+  file: string,
+  plugin: TransformPluginContext,
+  add?: (document: DocumentNode, level: number) => void,
+  level = 0,
+  seen = new Set<string>(),
+) {
+  const {imports, source} = extractGraphQLImports(code);
+  const document = parse(source);
+
+  add?.(document, level);
+
+  if (imports.length === 0) {
+    return document;
+  }
+
+  const resolvedImports = await Promise.all(
+    imports.map(async (imported) => {
+      if (seen.has(imported)) return;
+
+      seen.add(imported);
+
+      const resolvedId = await plugin.resolve(imported, file);
+
+      if (resolvedId == null) {
+        throw new Error(
+          `Could not find ${JSON.stringify(imported)} from ${JSON.stringify(
+            file,
+          )}`,
+        );
+      }
+
+      plugin.addWatchFile(resolvedId.id);
+      const contents = await readFile(resolvedId.id, {
+        encoding: 'utf8',
+      });
+
+      return loadDocument(
+        contents,
+        resolvedId.id,
+        plugin,
+        add,
+        level + 1,
+        seen,
+      );
+    }),
+  );
+
+  for (const importedDocument of resolvedImports) {
+    if (importedDocument == null) continue;
+    (document.definitions as any[]).push(...importedDocument.definitions);
+  }
+
+  return document;
+}

package/source/index.ts

@@ -1,6 +1,5 @@
 export {magicModuleEnv, type MagicModuleEnvOptions} from './env.ts';
 export {
-  quiltApp,
   quiltAppBrowser,
   quiltAppServer,
   magicModuleAppComponent,

package/source/shared/source-code.ts

@@ -0,0 +1,64 @@
+import {createRequire} from 'module';
+
+import babel from '@rollup/plugin-babel';
+
+const require = createRequire(import.meta.url);
+
+export function sourceCode({
+  mode,
+  targets,
+}: {
+  mode?: 'development' | 'production';
+  targets?: string[];
+}) {
+  return babel({
+    configFile: false,
+    babelrc: false,
+    presets: [
+      require.resolve('@babel/preset-typescript'),
+      [
+        require.resolve('@babel/preset-react'),
+        {
+          runtime: 'automatic',
+          importSource: 'react',
+          development: mode === 'development',
+        },
+      ],
+      [
+        require.resolve('@babel/preset-env'),
+        {
+          // @ts-expect-error This is a valid option
+          corejs: '3.15',
+          useBuiltIns: 'usage',
+          bugfixes: true,
+          shippedProposals: true,
+          // I thought I wanted this on, but if you do this, Babel
+          // stops respecting the top-level `targets` option and tries
+          // to use the targets passed to the preset directly instead.
+          ignoreBrowserslistConfig: true,
+        } satisfies import('@babel/preset-env').Options,
+      ],
+    ],
+    plugins: [
+      [
+        require.resolve('@babel/plugin-proposal-decorators'),
+        {version: '2023-01'},
+      ],
+    ],
+    targets,
+    extensions: [
+      '.ts',
+      '.tsx',
+      '.mts',
+      '.mtsx',
+      '.js',
+      '.jsx',
+      '.es6',
+      '.es',
+      '.mjs',
+    ],
+    exclude: 'node_modules/**',
+    babelHelpers: 'bundled',
+    skipPreflightCheck: true,
+  });
+}