houdini 2.0.0-next.8 → 2.0.0

package/build/lib/types.d.ts

@@ -1,314 +1,103 @@
-import type * as graphql from 'graphql';
 import type * as recast from 'recast';
-import type { CustomPluginOptions, InputOptions, LoadResult, MinimalPluginContext, NormalizedInputOptions, NullValue, ObjectHook, PluginContext, ResolveIdResult, SourceMapInput } from 'rollup';
-import type { ConfigEnv, ResolvedConfig, UserConfig, ViteDevServer } from 'vite';
-import type { ConfigFile } from '../runtime/lib/config';
-import type { ArtifactKinds, BaseCompiledDocument, DocumentArtifact, ValueOf } from '../runtime/lib/types';
-import type { TransformPage } from '../vite/houdini';
-import type { Config } from './config';
-import type { Adapter } from './router';
-type Program = recast.types.namedTypes.Program;
-export type Maybe<T> = T | null | undefined;
-export type Script = Program;
-export type TransformDocument = {
-    instance: Maybe<Script>;
-    config: Config;
-    dependencies: string[];
-    filename: string;
-};
-/**
- * The result of collecting documents from source code
- */
-export type Document = {
-    /**
-     * The name of the document.
-     */
-    name: string;
-    /**
-     * A field you can use to distinguish documents by type (query, mutation, subscription, fragment)
-     */
-    kind: ArtifactKinds;
-    /**
-     * The artifact generated for the document. This will only have a value in the last phase
-     * of the Generation Pipeline.
-     */
-    artifact: DocumentArtifact | null;
-    /**
-     * The path of the file containing this document
-     */
-    filename: string;
-    /**
-     * The parsed document. This value should be modified throughout the pipeline.
-     * */
-    document: graphql.DocumentNode;
-    /**
-     * Whether an artifact should be generated for the document. This should be set to false for internal
-     * or virtual documents .
-     */
-    generateArtifact: boolean;
-    /**
-     * Whether a runtime equivalent should be generated for the document. This should be set to false for internal
-     * or virtual documents .
-     */
-    generateStore: boolean;
-    /**
-     * The original document string that the user passed
-     */
-    originalString: string;
-    /**
-     * The parsed document that the user provided
-     * */
-    originalParsed: graphql.DocumentNode;
-    /**
-     * Refetch logic that has been built up throughout the pipeline
-     */
-    refetch?: BaseCompiledDocument<'HoudiniQuery'>['refetch'];
-};
+import type { SourceMapInput } from 'rollup';
+import type { Config } from './config.js';
 export declare const LogLevel: {
-    readonly Full: "full";
+    readonly Quiet: "quiet";
     readonly Summary: "summary";
     readonly ShortSummary: "short-summary";
-    readonly Quiet: "quiet";
+    readonly Verbose: "full";
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export type ProjectManifest = {
+    /** All of the pages in the project */
+    pages: Record<string, PageManifest>;
+    /** All of the layouts in the project */
+    layouts: Record<string, PageManifest>;
+    /** All of the page queries in the project */
+    page_queries: Record<string, QueryManifest>;
+    /** All of the layout queries in the project */
+    layout_queries: Record<string, QueryManifest>;
+    /** All of the artifacts in the project */
+    artifacts: string[];
+    /** Whether or not there is a local schema defined */
+    local_schema: boolean;
+    /** Whether or not there is a custom instance of yoga defined */
+    local_yoga: boolean;
+    /** Information about componentFields defined in the project */
+    component_fields: Record<string, {
+        filepath: string;
+    }>;
 };
-export type LogLevels = ValueOf<typeof LogLevel>;
-export type Plugin = (args?: PluginConfig) => Promise<(PluginHooks | PluginInit) | (PluginHooks | PluginInit)[] | null | false>;
-export type PluginInit = {
-    __plugin_init__: boolean;
-    plugin: Plugin;
+export type PageManifest = {
+    id: string;
+    /** the name of every query that the page depends on */
+    queries: string[];
+    /** the list of queries that this page could potentially ask for */
+    query_options: string[];
+    /** the full url pattern of the page */
+    url: string;
+    /** the ids of layouts that wrap this page */
+    layouts: string[];
+    /** The filepath of the unit */
+    path: string;
+    /**
+     * The name and type of every route paramter that this page can use.
+     * null indicates the type is unknown (not constrained by a query)
+     **/
+    params: Record<string, {
+        type: string;
+        wrappers: string[];
+    } | null>;
+};
+export type QueryManifest = {
+    /** the name of the query */
     name: string;
-    config?: {};
-    local?: string;
-    with(config: {}): PluginInit;
+    /** the url tied with the query */
+    url: string;
+    /** wether the query uses the loading directive (ie, wants a fallback) */
+    loading: boolean;
+    /** The filepath of the unit */
+    path: string;
+    /** The name and GraphQL type for the variables that this query cares about */
+    variables: Record<string, {
+        wrappers: string[];
+        type: string;
+    }>;
 };
-export type PluginHooks = {
-    /**
-     * Specify the priority for the hook. The order is before -> core -> after.
-     * @default 'before'
-     */
-    order?: 'before' | 'after' | 'core';
-    /**
-     * Add extensions to the list that houdini uses to find valid source files
-     */
-    extensions?: string[];
-    /**
-     * A relative path from the file exporting your plugin to a runtime that will be
-     * automatically included with your
-     */
-    includeRuntime?: string | {
-        esm: string;
-        commonjs: string;
-    };
-    /**
-     * A relative path from the file exporting your plugin to a runtime that can be
-     * added to the project before generating artifacts. This is useful for plugins
-     * that want to add third-party documents to the user's application.
-     */
-    staticRuntime?: string | {
-        esm: string;
-        commonjs: string;
-    };
-    /**
-     * Transform the plugin's runtime while houdini is copying it .
-     * You must have passed a value to includeRuntime for this hook to matter.
-     */
-    transformRuntime?: Record<string, (args: {
-        config: Config;
-        content: string;
-        importStatement: (where: string, as: string) => string;
-        exportDefaultStatement: (val: string) => string;
-        exportStarStatement: (val: string) => string;
-    }) => string> | ((docs: Document[], opts: {
-        config: Config;
-    }) => Record<string, (args: {
-        config: Config;
-        content: string;
-        importStatement: (where: string, as: string) => string;
-        exportDefaultStatement: (val: string) => string;
-        exportStarStatement: (val: string) => string;
-    }) => string>);
-    /**
-     * An module with an default export that sets configuration values.
-     */
-    config?: string;
-    /**
-     *
-     * Add environment variables to houdini's pipeline (ie, for schema polling headers, url, etc.)
-     */
-    env?: (args: {
-        env: any;
-        config: Config;
-    }) => Promise<Record<string, string>>;
-    /**
-     * Invoked after all plugins have loaded and modified config values.
-     */
-    afterLoad?: (args: {
-        config: Config;
-    }) => Promise<void> | void;
-    /**
-     * A filter for whether a file should be included in the the processing. Return true to include.
-     */
-    include?: (args: {
-        config: Config;
-        filepath: string;
-    }) => boolean | null | undefined;
-    /**
-     * A filter for whether a file should be included in the the processing. Return false to include.
-     */
-    exclude?: (args: {
-        config: Config;
-        filepath: string;
-    }) => boolean | null | undefined;
-    /**
-     * Configure the codegen pipeline to extract graphql documents out of a file.
-     */
-    extractDocuments?: (args: {
-        config: Config;
-        filepath: string;
-        content: string;
-    }) => Promise<string[] | null> | string[] | null;
-    /**
-     * Can be used to add custom definitions to your project's schema. Definitions (like directives) added
-     * here are automatically removed from the document before they are sent to the server. Useful
-     * in connection with artifactData or artifact_selection to embed data in the artifact.
-     */
-    schema?: (args: {
-        config: Config;
-    }) => string;
-    /**
-     * A hook to transform the documents before they are validated.
-     */
-    beforeValidate?: (args: {
-        config: Config;
-        documents: Document[];
-    }) => Promise<void> | void;
-    /**
-     * A hook to validate all of the documents in a project.
-     */
-    validate?: (args: {
-        config: Config;
-        documents: Document[];
-    }) => Promise<void> | void;
-    /**
-     * A hook to transform the documents after they are validated.
-     */
-    afterValidate?: (args: {
-        config: Config;
-        documents: Document[];
-    }) => Promise<void> | void;
-    /**
-     * A hook to transform the documents before documents are generated.
-     */
-    beforeGenerate?: (args: {
-        config: Config;
-        documents: Document[];
-    }) => Promise<void> | void;
-    /**
-     * A hook to embed metadata at the root of the artifact.
-     */
-    artifactData?: (args: {
-        config: Config;
-        document: Document;
-    }) => Record<string, any> | void;
-    /**
-     * A hook to customize the hash generated for your document.
-     */
-    hash?: (args: {
-        config: Config;
-        document: Document;
-    }) => string;
-    /**
-     * A hook to customize the return type of the graphql function. If you need to add an import to the file
-     * in order to resolve the import, you can use the `ensureImport` utility.
-     */
-    graphqlTagReturn?: (args: {
-        config: Config;
-        document: Document;
-        ensureImport: (import_args: {
-            identifier: string;
-            module: string;
-        }) => void;
-    }) => string | undefined;
-    /**
-     * A hook to modify the root `index.js` of the generated runtime.
-     */
-    indexFile?: ModuleIndexTransform;
-    /**
-     * A hook to generate custom files for every document in a project.
-     */
-    generate?: GenerateHook;
-    /**
-     * A hook to modify the generated artifact before it is persisted
-     */
-    artifactEnd?: (args: {
-        config: Config;
-        document: Document;
-    }) => void;
-    /**
-     * Specify the plugins that should be added to the user's client because
-     * of this plugin.
-     */
-    clientPlugins?: Record<string, null | Record<string, any>> | ((config: ConfigFile, pluginConfig: any) => Record<string, null | Record<string, any>>);
-    /**
-     * A hook to transform the source file to support desired APIs.
-     */
-    transformFile?: (page: TransformPage) => Promise<{
-        code: string;
-        map?: SourceMapInput | string;
-    }> | {
-        code: string;
-        map?: SourceMapInput | string;
-    };
-    vite?: {
-        config?: (config: Config, env: ConfigEnv) => UserConfig | Promise<UserConfig>;
-        buildStart?: (this: PluginContext, options: NormalizedInputOptions & {
-            houdiniConfig: Config;
-        }) => void | Promise<void>;
-        buildEnd?: (this: PluginContext, error?: Error, houdiniConfig?: Config) => void | Promise<void>;
-        closeBundle?: (this: PluginContext, config: Config) => void | Promise<void>;
-        configResolved?: ObjectHook<(this: void, config: ResolvedConfig) => void | Promise<void>>;
-        options?: (this: MinimalPluginContext, options: InputOptions & {
-            houdiniConfig: Config;
-        }) => InputOptions | NullValue;
-        resolveId?: ObjectHook<(this: PluginContext, source: string, importer: string | undefined, options: {
-            config: Config;
-            custom?: CustomPluginOptions;
-            ssr?: boolean;
-            isEntry: boolean;
-        }) => Promise<ResolveIdResult> | ResolveIdResult>;
-        load?: ObjectHook<(this: PluginContext, id: string, options: {
-            config: Config;
-            ssr?: boolean;
-        }) => Promise<LoadResult> | LoadResult>;
-        configureServer?: ObjectHook<(this: void, server: ViteDevServer & {
-            houdiniConfig: Config;
-        }) => (() => void) | void | Promise<(() => void) | void>, {}> | undefined;
-    };
+export declare const PaginateMode: {
+    readonly Infinite: "Infinite";
+    readonly SinglePage: "SinglePage";
+};
+type ValuesOf<T> = T[keyof T];
+export type PaginateModes = ValuesOf<typeof PaginateMode>;
+export declare const CachePolicy: {
+    readonly CacheOrNetwork: "CacheOrNetwork";
+    readonly CacheOnly: "CacheOnly";
+    readonly NetworkOnly: "NetworkOnly";
+    readonly CacheAndNetwork: "CacheAndNetwork";
+    readonly NoCache: "NoCache";
 };
-type ModuleIndexTransform = (arg: {
+export type CachePolicies = ValuesOf<typeof CachePolicy>;
+export type Maybe<T> = T | null | undefined;
+export type Script = Program;
+type Program = recast.types.namedTypes.Program;
+export interface TransformPage {
     config: Config;
     content: string;
-    exportDefaultAs(args: {
-        module: string;
-        as: string;
-    }): string;
-    exportStarFrom(args: {
-        module: string;
-    }): string;
-    pluginRoot: string;
-    typedef: boolean;
-    documents: Document[];
-}) => string;
-export type GenerateHook = (args: GenerateHookInput) => Promise<void> | void;
-export type GenerateHookInput = {
-    config: Config;
-    documents: Document[];
-    pluginRoot: string;
+    map?: SourceMapInput;
+    filepath: string;
+    watch_file: (path: string) => void;
+}
+export declare const ArtifactKind: {
+    readonly Query: "HoudiniQuery";
+    readonly Subscription: "HoudiniSubscription";
+    readonly Mutation: "HoudiniMutation";
+    readonly Fragment: "HoudiniFragment";
 };
-export type PluginConfig = {
-    configPath?: string;
-    adapter?: Adapter;
-} & Partial<ConfigFile>;
-export * from '../runtime/lib/types';
-export * from '../runtime/lib/config';
-export * from '../runtime/client';
-export type ValueMap = Record<string, graphql.ValueNode>;
+export type ArtifactKinds = ValuesOf<typeof ArtifactKind>;
+export declare const CompiledFragmentKind: "HoudiniFragment";
+export declare const CompiledMutationKind: "HoudiniMutation";
+export declare const CompiledQueryKind: "HoudiniQuery";
+export declare const CompiledSubscriptionKind: "HoudiniSubscription";
+export type CompiledDocumentKind = ArtifactKinds;
+export {};

package/build/lib/types.js

@@ -0,0 +1,37 @@
+const LogLevel = {
+  Quiet: "quiet",
+  Summary: "summary",
+  ShortSummary: "short-summary",
+  Verbose: "full"
+};
+const PaginateMode = {
+  Infinite: "Infinite",
+  SinglePage: "SinglePage"
+};
+const CachePolicy = {
+  CacheOrNetwork: "CacheOrNetwork",
+  CacheOnly: "CacheOnly",
+  NetworkOnly: "NetworkOnly",
+  CacheAndNetwork: "CacheAndNetwork",
+  NoCache: "NoCache"
+};
+const ArtifactKind = {
+  Query: "HoudiniQuery",
+  Subscription: "HoudiniSubscription",
+  Mutation: "HoudiniMutation",
+  Fragment: "HoudiniFragment"
+};
+const CompiledFragmentKind = ArtifactKind.Fragment;
+const CompiledMutationKind = ArtifactKind.Mutation;
+const CompiledQueryKind = ArtifactKind.Query;
+const CompiledSubscriptionKind = ArtifactKind.Subscription;
+export {
+  ArtifactKind,
+  CachePolicy,
+  CompiledFragmentKind,
+  CompiledMutationKind,
+  CompiledQueryKind,
+  CompiledSubscriptionKind,
+  LogLevel,
+  PaginateMode
+};

package/build/lib/walk.d.ts

@@ -1,8 +1,12 @@
-import type { BaseNode } from 'estree-walker';
+export type BaseNode = {
+    type: string;
+    start?: number;
+    end?: number;
+};
 import * as graphql from 'graphql';
-import type { CompiledDocumentKind } from '../runtime/lib/types';
-import type { Config } from './config';
-import type { Script } from './types';
+import type { Config } from './config.js';
+import type { CompiledDocumentKind } from './types.js';
+import { type Script } from './types.js';
 export type EmbeddedGraphqlDocument = {
     parsedDocument: graphql.DocumentNode;
     artifact: {
@@ -14,16 +18,17 @@ export type EmbeddedGraphqlDocument = {
         replaceWith: (node: BaseNode) => void;
     };
     tagContent: string;
-    parent: BaseNode;
+    parent: BaseNode | null;
 };
 type GraphqlTagWalker = {
     skipGraphqlType?: boolean;
     where?: (tag: graphql.DocumentNode, ast: {
         node: BaseNode;
-        parent: BaseNode;
+        parent: BaseNode | null;
     }) => boolean;
     dependency?: (fp: string) => void;
     tag: (tag: EmbeddedGraphqlDocument) => void | Promise<void>;
 };
 export declare function find_graphql(config: Config, parsedScript: Script, walker: GraphqlTagWalker): Promise<void>;
+export declare function extractDefinition(document: graphql.DocumentNode): graphql.ExecutableDefinitionNode;
 export {};

package/build/lib/walk.js

@@ -0,0 +1,138 @@
+import { asyncWalk } from "estree-walker";
+import * as graphql from "graphql";
+import {
+  CompiledFragmentKind,
+  CompiledMutationKind,
+  CompiledQueryKind,
+  CompiledSubscriptionKind
+} from "./types.js";
+async function find_graphql(config, parsedScript, walker) {
+  await asyncWalk(parsedScript, {
+    async enter(node, parent) {
+      if (node.type !== "TaggedTemplateExpression" && node.type !== "CallExpression" && node.type !== "TSPropertySignature" && node.type !== "VariableDeclaration") {
+        return;
+      }
+      let documentString = "";
+      let _propName = "";
+      if (node.type === "TaggedTemplateExpression") {
+        const expr = node;
+        if (expr.tag.type !== "Identifier" || expr.tag.name !== "graphql") {
+          return;
+        }
+        documentString = expr.quasi.quasis[0].value.raw;
+      } else if (node.type === "CallExpression") {
+        const expr = node;
+        if (expr.callee.type !== "Identifier" || expr.callee.name !== "graphql" || expr.arguments.length !== 1) {
+          return;
+        }
+        const argument = expr.arguments[0];
+        if (argument.type === "TemplateLiteral") {
+          documentString = argument.quasis[0].value.raw;
+        } else if (argument.type === "StringLiteral") {
+          documentString = argument.value;
+        } else {
+          return;
+        }
+      } else if (node.type === "TSPropertySignature" && !walker.skipGraphqlType) {
+        const signature = node;
+        if (signature.typeAnnotation?.typeAnnotation?.type !== "TSTypeReference") {
+          return;
+        }
+        const annotation = signature.typeAnnotation?.typeAnnotation;
+        if (annotation.typeName.type !== "Identifier") {
+          return;
+        }
+        if (annotation.typeName.name !== "GraphQL") {
+          return;
+        }
+        if (annotation.typeParameters?.params[0].type !== "TSLiteralType") {
+          return;
+        }
+        const literal = annotation.typeParameters?.params[0];
+        if (literal.literal.type === "StringLiteral") {
+          documentString = literal.literal.value;
+        } else if (literal.literal.type === "TemplateLiteral") {
+          documentString = literal.literal.quasis[0].value.raw;
+        }
+        if (signature.key.type === "Identifier") {
+          _propName = signature.key.name;
+        }
+      } else if (!documentString) {
+        return;
+      }
+      const parsedTag = graphql.parse(documentString);
+      if (walker.where && !walker.where(parsedTag, { node, parent })) {
+        return;
+      }
+      let anonOkay = false;
+      let definitions = [
+        { raw: documentString, parsed: extractDefinition(parsedTag) }
+      ];
+      const name = definitions[0].parsed.name?.value;
+      let kind;
+      if (definitions[0].parsed.kind === "FragmentDefinition") {
+        kind = CompiledFragmentKind;
+      } else {
+        if (definitions[0].parsed.operation === "query") {
+          kind = CompiledQueryKind;
+        } else if (definitions[0].parsed.operation === "mutation") {
+          kind = CompiledMutationKind;
+        } else {
+          kind = CompiledSubscriptionKind;
+        }
+      }
+      if (kind === CompiledQueryKind) {
+        anonOkay = definitions[0].parsed.selectionSet.selections.every(
+          (selection) => selection.kind === "InlineFragment" && selection.directives?.find(
+            (directive) => directive.name.value === "componentField"
+          )
+        );
+        if (name) {
+          definitions = [{ parsed: definitions[0].parsed, raw: definitions[0].raw }];
+        }
+      }
+      if (!name && !anonOkay) {
+        throw new Error("Could not find definition name");
+      }
+      walker.dependency?.(config.artifactPath(parsedTag));
+      for (const definition of definitions) {
+        const name2 = definition.parsed.name?.value;
+        if (!name2) {
+          continue;
+        }
+        await walker.tag({
+          parsedDocument: {
+            kind: graphql.Kind.DOCUMENT,
+            definitions: [definition.parsed]
+          },
+          node: {
+            ...node,
+            ...this,
+            remove: this.remove,
+            replaceWith: this.replace
+          },
+          artifact: {
+            name: name2,
+            kind
+          },
+          parent,
+          tagContent: definition.raw
+        });
+      }
+    }
+  });
+}
+function extractDefinition(document) {
+  if (document.definitions.length !== 1) {
+    throw new Error("Encountered document with multiple definitions");
+  }
+  const definition = document.definitions[0];
+  if (definition.kind !== "OperationDefinition" && definition.kind !== "FragmentDefinition") {
+    throw new Error("Encountered document without a fragment or operation definition");
+  }
+  return definition;
+}
+export {
+  extractDefinition,
+  find_graphql
+};

package/build/node/index.d.ts

@@ -0,0 +1,44 @@
+import { type Db } from '../lib/db.js';
+export type { Db } from '../lib/db.js';
+export type PipelineHook = 'config' | 'afterLoad' | 'schema' | 'extractDocuments' | 'afterExtract' | 'beforeValidate' | 'validate' | 'afterValidate' | 'beforeGenerate' | 'generateDocuments' | 'generateRuntime' | 'afterGenerate' | 'environment' | 'indexFile';
+export type PluginContext = {
+    taskId: string;
+    pluginDirectory: string;
+    db: Db;
+    invokeHook(hook: string, payload?: Record<string, any>, options?: {
+        parallel?: boolean;
+    }): Promise<Record<string, any>>;
+};
+export type TransformFn = (source: string, content: string) => Promise<string> | string;
+export type HookHandler = (ctx: PluginContext, payload: Record<string, any>) => Promise<Record<string, any> | string[] | string | undefined> | Record<string, any> | string[] | string | undefined;
+export type NodePluginConfig = {
+    name: string;
+    order: 'before' | 'after' | 'core';
+    hooks: Partial<Record<PipelineHook, HookHandler>>;
+    includeRuntime?: string;
+    staticRuntime?: string;
+    transformRuntime?: TransformFn;
+    transformStaticRuntime?: TransformFn;
+    configModule?: string;
+    clientPlugins?: Record<string, any>;
+};
+export declare class PluginError extends Error {
+    detail?: string;
+    locations?: Array<{
+        filepath: string;
+        line?: number;
+        column?: number;
+    }>;
+    kind?: string;
+    constructor(opts: {
+        message: string;
+        detail?: string;
+        locations?: Array<{
+            filepath: string;
+            line?: number;
+            column?: number;
+        }>;
+        kind?: string;
+    });
+}
+export declare function plugin(config: NodePluginConfig): void;