houdini 2.0.0-next.4 → 2.0.0-next.40

package/build/cmd/pullSchema.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import * as path from "../lib/path.js";
+import { get_config } from "../lib/project.js";
+import { pull_schema } from "../lib/schema.js";
+async function pullSchema_default(args) {
+  const config = await get_config({ skip_schema: true });
+  const apiURL = await config.api_url();
+  if (!apiURL) {
+    console.log(
+      "\u274C Your project does not have a remote endpoint configured. Please provide one with the `apiUrl` value in your houdini.config.js file."
+    );
+    process.exit(1);
+  }
+  const headers = await config.schema_pull_headers();
+  const targetPath = args.output ? path.resolve(args.output) : config.config_file.schemaPath ?? path.resolve(process.cwd(), "schema.json");
+  await pull_schema(apiURL, config.config_file.watchSchema?.timeout ?? 3e4, targetPath, headers);
+}
+export {
+  pullSchema_default as default
+};

package/build/lib/ast.js

@@ -0,0 +1,71 @@
+import * as recast from "recast";
+const _AST = recast.types.builders;
+function find_insert_index(script) {
+  let insert_index = script.body.findIndex((statement) => {
+    return statement.type !== "ImportDeclaration";
+  });
+  if (insert_index === -1) {
+    insert_index = script.body.length;
+  }
+  return insert_index;
+}
+function find_exported_fn(body, name) {
+  for (const statement of body) {
+    if (statement.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const exportDeclaration = statement;
+    if (exportDeclaration.declaration?.type === "FunctionDeclaration") {
+      const value = exportDeclaration.declaration;
+      if (value.id?.name === name) {
+        return {
+          declaration: exportDeclaration.declaration,
+          export: exportDeclaration
+        };
+      }
+    } else if (exportDeclaration.declaration?.type === "VariableDeclaration") {
+      const value = exportDeclaration.declaration;
+      if (value.declarations.length !== 1 || value.declarations[0].type !== "VariableDeclarator" || value.declarations[0].id.type !== "Identifier" || value.declarations[0].id.name !== name) {
+        continue;
+      }
+      const declaration = value.declarations[0];
+      let { init } = declaration;
+      if (!init) {
+        continue;
+      }
+      if (init.type === "TSSatisfiesExpression") {
+        init = init.expression;
+      }
+      if (init.type === "CallExpression" && init.arguments[0] && (init.arguments[0].type === "FunctionExpression" || init.arguments[0].type === "ArrowFunctionExpression")) {
+        init = init.arguments[0];
+      }
+      if (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression") {
+        return { declaration: init, export: exportDeclaration };
+      }
+      if (init.type === "Identifier" || init.type === "CallExpression") {
+        return { declaration: init, export: exportDeclaration };
+      }
+    } else {
+    }
+  }
+  const exported = body.find(
+    (expression) => expression.type === "ExportNamedDeclaration" && (expression.declaration?.type === "FunctionDeclaration" && expression.declaration.id?.name === name || expression.declaration?.type === "VariableDeclaration" && expression.declaration.declarations.length === 1 && expression.declaration.declarations[0].type === "Identifier" && expression.declaration.declarations[0].name === name)
+  );
+  if (!exported) {
+    return null;
+  }
+  return {
+    declaration: exported.declaration,
+    export: exported
+  };
+}
+function find_exported_id(program, name) {
+  return program.body.find(
+    (statement) => statement.type === "ExportNamedDeclaration" && statement.declaration?.type === "VariableDeclaration" && statement.declaration.declarations.length === 1 && statement.declaration.declarations[0].type === "VariableDeclarator" && statement.declaration.declarations[0].id.type === "Identifier" && statement.declaration.declarations[0].id.name === name
+  );
+}
+export {
+  find_exported_fn,
+  find_exported_id,
+  find_insert_index
+};

package/build/lib/codegen.d.ts

@@ -0,0 +1,57 @@
+import * as conventions from '../router/conventions.js';
+import type { Config } from './config.js';
+import { type Db } from './db.js';
+import type { ProjectManifest } from './types.js';
+export type PluginSpec = {
+    name: string;
+    port: number;
+    directory: string;
+    hooks: Set<string>;
+    order: 'before' | 'after' | 'core';
+};
+export type Adapter = ((args: {
+    config: Config;
+    conventions: typeof conventions;
+    sourceDir: string;
+    publicBase: string;
+    outDir: string;
+    manifest: ProjectManifest;
+    adapterPath: string;
+}) => void | Promise<void>) & {
+    includePaths?: Record<string, string> | ((args: {
+        config: Config;
+    }) => Record<string, string>);
+    disableServer?: boolean;
+    pre?: (args: {
+        config: Config;
+        conventions: typeof conventions;
+        sourceDir: string;
+        publicBase: string;
+        outDir: string;
+    }) => Promise<void> | void;
+};
+export declare function connect_db(config: Config): Promise<[Db, string]>;
+export declare function init_db(config: Config, preserve: boolean): Promise<[Db, string]>;
+export type CompilerProxy = {
+    close: () => Promise<void>;
+    trigger_hook: (name: PipelineHook, opts?: {
+        parallel_safe?: boolean;
+        payload?: {};
+        task_id?: string;
+    }) => Promise<Record<string, any> | null>;
+    database_path: string;
+    run_pipeline: (options: RunPipelineOptions) => Promise<Record<PipelineHook, Record<string, any>>>;
+    /** Serializes concurrent pipeline runs (HMR vs schema watcher) via a promise chain. */
+    pipeline_lock: <T>(fn: () => Promise<T>) => Promise<T>;
+};
+export declare function plugin_db_key(name: string): string;
+export declare function codegen_setup(config: Config, mode: string, db: Db, db_file: string): Promise<CompilerProxy>;
+export declare const PIPELINE_HOOKS: readonly ["Config", "AfterLoad", "Schema", "ExtractDocuments", "AfterExtract", "BeforeValidate", "Validate", "AfterValidate", "BeforeGenerate", "GenerateDocuments", "GenerateRuntime", "AfterGenerate"];
+export type PipelineHook = (typeof PIPELINE_HOOKS)[number];
+export type RunPipelineOptions = {
+    task_id?: string;
+    after?: PipelineHook;
+    start?: PipelineHook;
+    through?: PipelineHook;
+};
+export declare function run_pipeline(trigger_hook: CompilerProxy['trigger_hook'], options?: RunPipelineOptions): Promise<Record<PipelineHook, Record<string, any>>>;