@quilted/rollup 0.1.2 → 0.1.3

package/source/app.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 
-import type {Plugin} from 'rollup';
+import type {GetManualChunk, Plugin} from 'rollup';
 
 import {
   MAGIC_MODULE_ENTRY,
@@ -27,7 +27,7 @@ export interface AppOptions {
    *
    * @example './App.tsx'
    */
-  entry?: string;
+  app?: string;
 
   /**
    * Whether to include GraphQL-related code transformations.
@@ -44,34 +44,6 @@ export interface AppOptions {
   env?: MagicModuleEnvOptions;
 }
 
-export function quiltApp({env, entry}: AppOptions = {}) {
-  return {
-    name: '@quilted/app',
-    async options(originalOptions) {
-      const newPlugins = rollupPluginsToArray(originalOptions.plugins);
-      const newOptions = {...originalOptions, plugins: newPlugins};
-
-      if (env) {
-        const {magicModuleEnv, replaceProcessEnv} = await import('./env.ts');
-
-        if (typeof env === 'boolean') {
-          newPlugins.push(replaceProcessEnv({mode: 'production'}));
-          newPlugins.push(magicModuleEnv({mode: 'production'}));
-        } else {
-          newPlugins.push(replaceProcessEnv({mode: env.mode ?? 'production'}));
-          newPlugins.push(magicModuleEnv({mode: 'production', ...env}));
-        }
-      }
-
-      if (entry) {
-        newPlugins.push(magicModuleAppComponent({entry}));
-      }
-
-      return newOptions;
-    },
-  } satisfies Plugin;
-}
-
 export interface AppBrowserOptions extends AppOptions {
   /**
    * Customizes the magic `quilt:module/browser` entry module.
@@ -110,11 +82,11 @@ export interface AppBrowserAssetsOptions {
 }
 
 export function quiltAppBrowser({
-  entry,
+  app,
   env,
-  graphql,
   assets,
   module,
+  graphql = true,
 }: AppBrowserOptions = {}) {
   return {
     name: '@quilted/app/browser',
@@ -127,10 +99,33 @@ export function quiltAppBrowser({
         getNodePlugins(),
       ]);
 
-      newPlugins.push(quiltApp({env, entry, graphql}));
       newPlugins.push(...nodePlugins);
+
+      if (env) {
+        const {magicModuleEnv, replaceProcessEnv} = await import('./env.ts');
+
+        if (typeof env === 'boolean') {
+          newPlugins.push(replaceProcessEnv({mode: 'production'}));
+          newPlugins.push(magicModuleEnv({mode: 'production'}));
+        } else {
+          newPlugins.push(replaceProcessEnv({mode: env.mode ?? 'production'}));
+          newPlugins.push(magicModuleEnv({mode: 'production', ...env}));
+        }
+      }
+
+      if (app) {
+        newPlugins.push(magicModuleAppComponent({entry: app}));
+      }
+
       newPlugins.push(magicModuleAppBrowserEntry(module));
 
+      if (graphql) {
+        const {graphql} = await import('./graphql.ts');
+        newPlugins.push(
+          graphql({manifest: path.resolve(`manifests/graphql.json`)}),
+        );
+      }
+
       const minify = assets?.minify ?? true;
 
       if (minify) {
@@ -143,16 +138,28 @@ export function quiltAppBrowser({
           template: 'treemap',
           open: false,
           brotliSize: true,
-          filename: path.resolve('reports', `bundle-visualizer.html`),
+          filename: path.resolve(`reports/bundle-visualizer.html`),
         }),
       );
 
       return newOptions;
     },
+    outputOptions(originalOptions) {
+      return {
+        ...originalOptions,
+        // format: isESM ? 'esm' : 'systemjs',
+        format: 'esm',
+        dir: path.resolve(`build/assets`),
+        entryFileNames: `app.[hash].js`,
+        assetFileNames: `[name].[hash].[ext]`,
+        chunkFileNames: `[name].[hash].js`,
+        manualChunks: createManualChunksSorter(),
+      };
+    },
   } satisfies Plugin;
 }
 
-export interface AppServerOptions {
+export interface AppServerOptions extends AppOptions {
   /**
    * The entry module for the server of this app. This module must export a
    * `RequestRouter` object as its default export, which will be wrapped in
@@ -161,22 +168,60 @@ export interface AppServerOptions {
   entry?: string;
 }
 
-export function quiltAppServer(options: AppServerOptions = {}) {
+export function quiltAppServer({
+  app,
+  env,
+  graphql,
+  entry,
+}: AppServerOptions = {}) {
   return {
     name: '@quilted/app/server',
     async options(originalOptions) {
       const newPlugins = rollupPluginsToArray(originalOptions.plugins);
       const newOptions = {...originalOptions, plugins: newPlugins};
 
-      const [{magicModuleRequestRouterEntry}] = await Promise.all([
+      const [{magicModuleRequestRouterEntry}, nodePlugins] = await Promise.all([
         import('./request-router.ts'),
+        getNodePlugins(),
       ]);
 
+      newPlugins.push(...nodePlugins);
+
+      if (env) {
+        const {magicModuleEnv, replaceProcessEnv} = await import('./env.ts');
+
+        if (typeof env === 'boolean') {
+          newPlugins.push(replaceProcessEnv({mode: 'production'}));
+          newPlugins.push(magicModuleEnv({mode: 'production'}));
+        } else {
+          newPlugins.push(replaceProcessEnv({mode: env.mode ?? 'production'}));
+          newPlugins.push(magicModuleEnv({mode: 'production', ...env}));
+        }
+      }
+
+      if (app) {
+        newPlugins.push(magicModuleAppComponent({entry: app}));
+      }
+
       newPlugins.push(magicModuleRequestRouterEntry());
-      newPlugins.push(magicModuleAppRequestRouter(options));
+      newPlugins.push(magicModuleAppRequestRouter({entry}));
+
+      if (graphql) {
+        const {graphql} = await import('./graphql.ts');
+        newPlugins.push(graphql({manifest: false}));
+      }
 
       return newOptions;
     },
+    outputOptions(originalOptions) {
+      return {
+        ...originalOptions,
+        // format,
+        format: 'esm',
+        dir: path.resolve(`build/server`),
+        entryFileNames: 'server.js',
+      };
+    },
   } satisfies Plugin;
 }
 
@@ -259,3 +304,103 @@ export function magicModuleAppBrowserEntry({
     },
   });
 }
+
+const FRAMEWORK_CHUNK_NAME = 'framework';
+const POLYFILLS_CHUNK_NAME = 'polyfills';
+const VENDOR_CHUNK_NAME = 'vendor';
+const INTERNALS_CHUNK_NAME = 'internals';
+const SHARED_CHUNK_NAME = 'shared';
+const PACKAGES_CHUNK_NAME = 'packages';
+const GLOBAL_CHUNK_NAME = 'global';
+const FRAMEWORK_TEST_STRINGS: (string | RegExp)[] = [
+  '/node_modules/preact/',
+  '/node_modules/react/',
+  '/node_modules/js-cookie/',
+  '/node_modules/@quilted/quilt/',
+  '/node_modules/@preact/signals/',
+  '/node_modules/@preact/signals-core/',
+  // TODO I should turn this into an allowlist
+  /node_modules[/]@quilted[/](?!react-query|swr)/,
+];
+
+const POLYFILL_TEST_STRINGS = [
+  '/node_modules/@quilted/polyfills/',
+  '/node_modules/core-js/',
+  '/node_modules/whatwg-fetch/',
+  '/node_modules/regenerator-runtime/',
+  '/node_modules/abort-controller/',
+];
+
+const INTERNALS_TEST_STRINGS = [
+  '\x00commonjsHelpers.js',
+  '/node_modules/@babel/runtime/',
+];
+
+// When building from source, quilt packages are not in node_modules,
+// so we instead add their repo paths to the list of framework test strings.
+if (process.env.QUILT_FROM_SOURCE) {
+  FRAMEWORK_TEST_STRINGS.push('/quilt/packages/');
+}
+
+// Inspired by Vite: https://github.com/vitejs/vite/blob/c69f83615292953d40f07b1178d1ed1d72abe695/packages/vite/source/node/build.ts#L567
+function createManualChunksSorter(): GetManualChunk {
+  // TODO: make this more configurable, and make it so that we bundle more intelligently
+  // for split entries
+  const packagesPath = path.resolve('packages') + path.sep;
+  const globalPath = path.resolve('global') + path.sep;
+  const sharedPath = path.resolve('shared') + path.sep;
+
+  return (id, {getModuleInfo}) => {
+    if (INTERNALS_TEST_STRINGS.some((test) => id.includes(test))) {
+      return INTERNALS_CHUNK_NAME;
+    }
+
+    if (
+      FRAMEWORK_TEST_STRINGS.some((test) =>
+        typeof test === 'string' ? id.includes(test) : test.test(id),
+      )
+    ) {
+      return FRAMEWORK_CHUNK_NAME;
+    }
+
+    if (POLYFILL_TEST_STRINGS.some((test) => id.includes(test))) {
+      return POLYFILLS_CHUNK_NAME;
+    }
+
+    let bundleBaseName: string | undefined;
+    let relativeId: string | undefined;
+
+    if (id.includes('/node_modules/')) {
+      const moduleInfo = getModuleInfo(id);
+
+      // If the only dependency is another vendor, let Rollup handle the naming
+      if (moduleInfo == null) return;
+      if (
+        moduleInfo.importers.length > 0 &&
+        moduleInfo.importers.every((importer) =>
+          importer.includes('/node_modules/'),
+        )
+      ) {
+        return;
+      }
+
+      bundleBaseName = VENDOR_CHUNK_NAME;
+      relativeId = id.replace(/^.*[/]node_modules[/]/, '');
+    } else if (id.startsWith(packagesPath)) {
+      bundleBaseName = PACKAGES_CHUNK_NAME;
+      relativeId = id.replace(packagesPath, '');
+    } else if (id.startsWith(globalPath)) {
+      bundleBaseName = GLOBAL_CHUNK_NAME;
+      relativeId = id.replace(globalPath, '');
+    } else if (id.startsWith(sharedPath)) {
+      bundleBaseName = SHARED_CHUNK_NAME;
+      relativeId = id.replace(sharedPath, '');
+    }
+
+    if (bundleBaseName == null || relativeId == null) {
+      return;
+    }
+
+    return `${bundleBaseName}-${relativeId.split(path.sep)[0]?.split('.')[0]}`;
+  };
+}

package/source/graphql/transform.ts

@@ -0,0 +1,283 @@
+import {createHash} from 'crypto';
+
+import {print, parse} from 'graphql';
+import type {
+  DocumentNode,
+  TypedQueryDocumentNode,
+  DefinitionNode,
+  SelectionSetNode,
+  ExecutableDefinitionNode,
+  OperationDefinitionNode,
+  SelectionNode,
+  Location,
+} from 'graphql';
+import type {GraphQLOperation} from '@quilted/graphql';
+
+const IMPORT_REGEX = /^#import\s+['"]([^'"]*)['"];?[\s\n]*/gm;
+const DEFAULT_NAME = 'Operation';
+
+export interface EnhancedDocumentNode<
+  Data = Record<string, any>,
+  Variables = Record<string, any>,
+> extends TypedQueryDocumentNode<Data, Variables> {
+  readonly id: string;
+}
+
+export function cleanGraphQLDocument<
+  Data = Record<string, any>,
+  Variables = Record<string, any>,
+>(
+  document: DocumentNode | TypedQueryDocumentNode<Data, Variables>,
+  {removeUnused = true}: {removeUnused?: boolean | {exclude: Set<string>}} = {},
+): EnhancedDocumentNode<Data, Variables> {
+  if (removeUnused) {
+    removeUnusedDefinitions(document, {
+      exclude: removeUnused === true ? new Set() : removeUnused.exclude,
+    });
+  }
+
+  for (const definition of document.definitions) {
+    addTypename(definition);
+  }
+
+  const normalizedSource = minifyGraphQLSource(print(document));
+  const normalizedDocument = parse(normalizedSource);
+
+  for (const definition of normalizedDocument.definitions) {
+    stripLoc(definition);
+  }
+
+  // This ID is a hash of the full file contents that are part of the document,
+  // including other documents that are injected in, but excluding any unused
+  // fragments. This is useful for things like persisted queries.
+  const id = createHash('sha256').update(normalizedSource).digest('hex');
+
+  Reflect.defineProperty(normalizedDocument, 'id', {
+    value: id,
+    enumerable: true,
+    writable: false,
+    configurable: false,
+  });
+
+  Reflect.defineProperty(normalizedDocument, 'loc', {
+    value: stripDocumentLoc(normalizedDocument.loc),
+    enumerable: true,
+    writable: false,
+    configurable: false,
+  });
+
+  return normalizedDocument as any;
+}
+
+export function extractGraphQLImports(rawSource: string) {
+  const imports = new Set<string>();
+
+  const source = rawSource.replace(IMPORT_REGEX, (_, imported) => {
+    imports.add(imported);
+    return '';
+  });
+
+  return {imports: [...imports], source};
+}
+
+export function toGraphQLOperation<Data = unknown, Variables = unknown>(
+  documentOrSource: EnhancedDocumentNode<Data, Variables> | string,
+): GraphQLOperation<Data, Variables> {
+  const document =
+    typeof documentOrSource === 'string'
+      ? cleanGraphQLDocument(parse(documentOrSource))
+      : documentOrSource;
+
+  return {
+    id: document.id,
+    name: operationNameForDocument(document),
+    source: document.loc!.source.body,
+  };
+}
+
+function operationNameForDocument(document: DocumentNode) {
+  return document.definitions.find(
+    (definition): definition is OperationDefinitionNode =>
+      definition.kind === 'OperationDefinition',
+  )?.name?.value;
+}
+
+function removeUnusedDefinitions(
+  document: DocumentNode,
+  {exclude}: {exclude: Set<string>},
+) {
+  const usedDefinitions = new Set<DefinitionNode>();
+  const dependencies = definitionDependencies(document.definitions);
+
+  const markAsUsed = (definition: DefinitionNode) => {
+    if (usedDefinitions.has(definition)) {
+      return;
+    }
+
+    usedDefinitions.add(definition);
+
+    for (const dependency of dependencies.get(definition) || []) {
+      markAsUsed(dependency);
+    }
+  };
+
+  for (const definition of document.definitions) {
+    if (definition.kind === 'FragmentDefinition') {
+      if (exclude.has(definition.name.value)) {
+        markAsUsed(definition);
+      }
+    } else {
+      markAsUsed(definition);
+    }
+  }
+
+  (document as any).definitions = [...usedDefinitions];
+}
+
+function definitionDependencies(definitions: readonly DefinitionNode[]) {
+  const executableDefinitions: ExecutableDefinitionNode[] = definitions.filter(
+    (definition) =>
+      definition.kind === 'OperationDefinition' ||
+      definition.kind === 'FragmentDefinition',
+  ) as any[];
+
+  const definitionsByName = new Map(
+    executableDefinitions.map<[string, DefinitionNode]>((definition) => [
+      definition.name ? definition.name.value : DEFAULT_NAME,
+      definition,
+    ]),
+  );
+
+  return new Map(
+    executableDefinitions.map<[DefinitionNode, DefinitionNode[]]>(
+      (executableNode) => [
+        executableNode,
+        [...collectUsedFragmentSpreads(executableNode, new Set())].map(
+          (usedFragment) => {
+            const definition = definitionsByName.get(usedFragment);
+
+            if (definition == null) {
+              throw new Error(
+                `You attempted to use the fragment '${usedFragment}' (in '${
+                  executableNode.name ? executableNode.name.value : DEFAULT_NAME
+                }'), but it does not exist. Maybe you forgot to import it from another document?`,
+              );
+            }
+
+            return definition;
+          },
+        ),
+      ],
+    ),
+  );
+}
+
+const TYPENAME_FIELD = {
+  kind: 'Field',
+  alias: null,
+  name: {kind: 'Name', value: '__typename'},
+};
+
+function addTypename(definition: DefinitionNode) {
+  for (const {selections} of selectionSetsForDefinition(definition)) {
+    const hasTypename = selections.some(
+      (selection) =>
+        selection.kind === 'Field' && selection.name.value === '__typename',
+    );
+
+    if (!hasTypename) {
+      (selections as any[]).push(TYPENAME_FIELD);
+    }
+  }
+}
+
+function collectUsedFragmentSpreads(
+  definition: DefinitionNode,
+  usedSpreads: Set<string>,
+) {
+  for (const selection of selectionsForDefinition(definition)) {
+    if (selection.kind === 'FragmentSpread') {
+      usedSpreads.add(selection.name.value);
+    }
+  }
+
+  return usedSpreads;
+}
+
+function selectionsForDefinition(
+  definition: DefinitionNode,
+): IterableIterator<SelectionNode> {
+  if (!('selectionSet' in definition) || definition.selectionSet == null) {
+    return [][Symbol.iterator]();
+  }
+
+  return selectionsForSelectionSet(definition.selectionSet);
+}
+
+function* selectionSetsForDefinition(
+  definition: DefinitionNode,
+): IterableIterator<SelectionSetNode> {
+  if (!('selectionSet' in definition) || definition.selectionSet == null) {
+    return [][Symbol.iterator]();
+  }
+
+  if (definition.kind !== 'OperationDefinition') {
+    yield definition.selectionSet;
+  }
+
+  for (const nestedSelection of selectionsForDefinition(definition)) {
+    if (
+      'selectionSet' in nestedSelection &&
+      nestedSelection.selectionSet != null
+    ) {
+      yield nestedSelection.selectionSet;
+    }
+  }
+}
+
+function* selectionsForSelectionSet({
+  selections,
+}: SelectionSetNode): IterableIterator<SelectionNode> {
+  for (const selection of selections) {
+    yield selection;
+
+    if ('selectionSet' in selection && selection.selectionSet != null) {
+      yield* selectionsForSelectionSet(selection.selectionSet);
+    }
+  }
+}
+
+type Writable<T> = {-readonly [K in keyof T]: T[K]};
+
+function stripDocumentLoc(loc?: Location) {
+  const normalizedLoc: Partial<Writable<Location>> = {...loc};
+  delete normalizedLoc.endToken;
+  delete normalizedLoc.startToken;
+  return normalizedLoc;
+}
+
+function stripLoc(value: unknown) {
+  if (Array.isArray(value)) {
+    value.forEach(stripLoc);
+  } else if (typeof value === 'object') {
+    if (value == null) {
+      return;
+    }
+
+    if ('loc' in value) {
+      delete (value as {loc: unknown}).loc;
+    }
+
+    for (const key of Object.keys(value)) {
+      stripLoc((value as any)[key]);
+    }
+  }
+}
+
+export function minifyGraphQLSource(source: string) {
+  return source
+    .replace(/#.*/g, '')
+    .replace(/\\n/g, ' ')
+    .replace(/\s\s+/g, ' ')
+    .replace(/\s*({|}|\(|\)|\.|:|,)\s*/g, '$1');
+}

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;
+}