houdini 2.0.0-next.8 → 2.0.0

package/build/lib/imports.d.ts

@@ -1,20 +1,35 @@
 import * as recast from 'recast';
-import type { Config } from './config';
-type Statement = recast.types.namedTypes.Statement;
-export declare function ensureArtifactImport({ config, artifact, body, local, withExtension, }: {
-    config: Config;
+import type { TransformPage, Script } from './types.js';
+type Identifier = recast.types.namedTypes.Identifier;
+export declare function ensure_imports(args: {
+    script: Script;
+    import?: string;
+    as?: never;
+    sourceModule: string;
+    importKind?: 'value' | 'type';
+}): {
+    ids: Identifier;
+    added: number;
+};
+export declare function ensure_imports(args: {
+    script: Script;
+    import?: string[];
+    as?: string[];
+    sourceModule: string;
+    importKind?: 'value' | 'type';
+}): {
+    ids: Identifier[];
+    added: number;
+};
+export declare function artifact_import({ script, artifact, local, }: {
+    page: TransformPage;
+    script: Script;
     artifact: {
         name: string;
     };
-    body: Statement[];
     local?: string;
-    withExtension?: boolean;
-}): string;
-export declare function ensureImports<_Count extends string[] | string>({ config, body, import: importID, sourceModule, importKind, }: {
-    config: Config;
-    body: Statement[];
-    import: _Count | null;
-    sourceModule: string;
-    importKind?: 'value' | 'type';
-}): _Count;
+}): {
+    id: recast.types.namedTypes.Identifier;
+    added: number;
+};
 export {};

package/build/lib/imports.js

@@ -0,0 +1,66 @@
+import * as recast from "recast";
+const AST = recast.types.builders;
+function ensure_imports({
+  script,
+  import: importID,
+  sourceModule,
+  importKind,
+  as
+}) {
+  if (!importID) {
+    const has_import = script.body.find(
+      (statement) => statement.type === "ImportDeclaration" && statement.source.value === sourceModule
+    );
+    if (!has_import) {
+      script.body.unshift({
+        type: "ImportDeclaration",
+        source: AST.stringLiteral(sourceModule),
+        importKind
+      });
+    }
+    return { ids: [], added: has_import ? 0 : 1 };
+  }
+  const idList = (Array.isArray(importID) ? importID : [importID]).map((id) => AST.identifier(id));
+  const toImport = idList.filter(
+    (identifier) => !script.body.find(
+      (statement) => statement.type === "ImportDeclaration" && statement.specifiers?.find(
+        (importSpecifier) => importSpecifier.type === "ImportSpecifier" && importSpecifier.imported.type === "Identifier" && importSpecifier.imported.name === identifier.name && importSpecifier.local?.name === identifier.name || importSpecifier.type === "ImportDefaultSpecifier" && importSpecifier.local?.type === "Identifier" && importSpecifier.local.name === identifier.name && importSpecifier.local.name === identifier.name
+      )
+    )
+  );
+  if (toImport.length > 0) {
+    script.body.unshift({
+      type: "ImportDeclaration",
+      source: AST.stringLiteral(sourceModule),
+      specifiers: toImport.map(
+        (identifier, i) => !Array.isArray(importID) ? AST.importDefaultSpecifier(identifier) : AST.importSpecifier(identifier, as?.[i] ? AST.identifier(as[i]) : identifier)
+      ),
+      importKind
+    });
+  }
+  for (const [i, target] of (as ?? []).entries()) {
+    if (target) {
+      idList[i] = AST.identifier(target);
+    }
+  }
+  return {
+    ids: Array.isArray(importID) ? idList : idList[0],
+    added: toImport.length
+  };
+}
+function artifact_import({
+  script,
+  artifact,
+  local
+}) {
+  const { ids, added } = ensure_imports({
+    script,
+    sourceModule: `$houdini/artifacts/${artifact.name}`,
+    import: local || `_${artifact.name}Artifact`
+  });
+  return { id: ids, added };
+}
+export {
+  artifact_import,
+  ensure_imports
+};

package/build/lib/index.d.ts

@@ -1,24 +1,17 @@
-export * from './pipeline';
-export * from './config';
-export * from './graphql';
-export * from './types';
-export * from './parse';
-export * from './imports';
-export * from './error';
-export * from './types';
-export * from './constants';
-export * from './introspection';
-export * from './cleanupFiles';
-export * from './deepMerge';
-export * from './plugin';
-export * from './detectTools';
-export * from '../runtime/router/match';
-export * from './typescript';
-export * from './watchAndRun';
-export * from './walk';
-export type { EmbeddedGraphqlDocument } from './walk';
-export * as fs from './fs';
-export * as path from './path';
-export * from './router';
-export { Cache } from '../runtime/cache/cache';
-export * from '../runtime/router/match';
+export * from './db.js';
+export * from './logger.js';
+export * from './project.js';
+export * from './codegen.js';
+export * as path from './path.js';
+export * as fs from './fs.js';
+export * from './sleep.js';
+export * from './config.js';
+export * from './types.js';
+export * from './parse.js';
+export * from './graphql.js';
+export * from './deepMerge.js';
+export * from './ast.js';
+export * from './pipeline.js';
+export * from './walk.js';
+export * from './imports.js';
+export * from './error.js';

package/build/lib/index.js

@@ -0,0 +1,21 @@
+export * from "./db.js";
+export * from "./logger.js";
+export * from "./project.js";
+export * from "./codegen.js";
+import * as path from "./path.js";
+import * as fs from "./fs.js";
+export * from "./sleep.js";
+export * from "./config.js";
+export * from "./types.js";
+export * from "./parse.js";
+export * from "./graphql.js";
+export * from "./deepMerge.js";
+export * from "./ast.js";
+export * from "./pipeline.js";
+export * from "./walk.js";
+export * from "./imports.js";
+export * from "./error.js";
+export {
+  fs,
+  path
+};

package/build/lib/logger.d.ts

@@ -0,0 +1,12 @@
+export declare class Logger {
+    readonly level: string;
+    private timers;
+    private order;
+    constructor(level?: string);
+    error(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    info(msg: string, minLevel?: string): void;
+    time(label: string): void;
+    timeEnd(label: string, minLevel: string): void;
+    at(minLevel: string): boolean;
+}

package/build/lib/logger.js

@@ -0,0 +1,45 @@
+import { LogLevel } from "./types.js";
+const LEVEL_ORDER = {
+  quiet: 0,
+  "short-summary": 1,
+  summary: 2,
+  full: 3
+};
+class Logger {
+  constructor(level = LogLevel.ShortSummary) {
+    this.level = level;
+    this.order = LEVEL_ORDER[level] ?? 1;
+  }
+  level;
+  timers = /* @__PURE__ */ new Map();
+  order;
+  error(msg, ...args) {
+    console.error(msg, ...args);
+  }
+  warn(msg, ...args) {
+    console.warn(msg, ...args);
+  }
+  info(msg, minLevel = LogLevel.Summary) {
+    if (this.order >= (LEVEL_ORDER[minLevel] ?? 1)) {
+      console.log(msg);
+    }
+  }
+  time(label) {
+    this.timers.set(label, performance.now());
+  }
+  timeEnd(label, minLevel) {
+    const start = this.timers.get(label);
+    if (start === void 0) return;
+    this.timers.delete(label);
+    if (this.order >= (LEVEL_ORDER[minLevel] ?? 1)) {
+      const ms = (performance.now() - start).toFixed(1);
+      console.log(`  ${label}: ${ms}ms`);
+    }
+  }
+  at(minLevel) {
+    return this.order >= (LEVEL_ORDER[minLevel] ?? 1);
+  }
+}
+export {
+  Logger
+};

package/build/lib/parse.d.ts

@@ -1,13 +1,12 @@
 import { type ParserOptions } from '@babel/parser';
 import type { Options } from 'recast';
-import type { Maybe, Script } from './types';
+import type { Maybe, Script } from './types.js';
 export type ParsedFile = Maybe<{
     script: Script;
     start: number;
     end: number;
 }>;
 export declare function parseJS(str: string, config?: Partial<ParserOptions>): Script;
-export declare function parseJSON(str: string): any;
 type PrintOptions = Options & {
     pretty?: boolean;
 };

package/build/lib/parse.js

@@ -0,0 +1,32 @@
+import { parse as parseJavascript } from "@babel/parser";
+import { parse as recastParse, print, prettyPrint } from "recast";
+import { deepMerge } from "./deepMerge.js";
+const defaultBabelConfig = {
+  plugins: ["typescript", "importAssertions", "decorators-legacy", "explicitResourceManagement"],
+  sourceType: "module"
+};
+function parseJS(str, config) {
+  const mergedConfig = config ? deepMerge("", defaultBabelConfig, config) : defaultBabelConfig;
+  return recastParse(str || "", {
+    parser: {
+      // tokens: true is required so recast doesn't fall back to esprima's tokenizer,
+      // which can't handle TypeScript syntax.
+      parse: (src) => parseJavascript(src, { ...mergedConfig, tokens: true })
+    }
+  }).program;
+}
+async function printJS(script, options) {
+  const defaultOptions = { tabWidth: 4 };
+  if (options?.pretty) {
+    return prettyPrint(
+      script,
+      options ? deepMerge("", defaultOptions, options) : defaultOptions
+    );
+  } else {
+    return print(script, options ? deepMerge("", defaultOptions, options) : defaultOptions);
+  }
+}
+export {
+  parseJS,
+  printJS
+};

package/build/lib/path.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import path from 'node:path';
 export declare const sep = "/";
 export declare function resolve(...parts: string[]): string;

package/build/lib/path.js

@@ -0,0 +1,44 @@
+import os from "node:os";
+import path from "node:path";
+const sep = "/";
+function resolve(...parts) {
+  return posixify(path.resolve(...parts));
+}
+function join(...parts) {
+  return posixify(path.join(...parts));
+}
+function extname(target) {
+  return path.extname(target);
+}
+function relative(from, to) {
+  return posixify(path.relative(from, to));
+}
+function basename(target) {
+  return path.basename(target);
+}
+function dirname(target) {
+  return path.dirname(target);
+}
+function isAbsolute(target) {
+  return path.isAbsolute(target);
+}
+function parse(target) {
+  return path.parse(target);
+}
+const posixify = (str) => str.replace(/\\/g, "/");
+function importPath(target) {
+  return ["win32", "win64"].includes(os.platform()) ? `file:///${target}` : target;
+}
+export {
+  basename,
+  dirname,
+  extname,
+  importPath,
+  isAbsolute,
+  join,
+  parse,
+  posixify,
+  relative,
+  resolve,
+  sep
+};

package/build/lib/pipeline.d.ts

@@ -1,3 +1,3 @@
-import type { Config } from './config';
+import type { Config } from './config.js';
 export type Transform<_TransformType> = null | ((config: Config, documents: _TransformType) => Promise<void> | void);
 export declare function runPipeline<_TransformType>(config: Config, pipeline: Transform<_TransformType>[], target: _TransformType): Promise<void>;

package/build/lib/pipeline.js

@@ -0,0 +1,8 @@
+async function runPipeline(config, pipeline, target) {
+  for (const transform of pipeline) {
+    await transform?.(config, target);
+  }
+}
+export {
+  runPipeline
+};

package/build/lib/plugins.d.ts

@@ -0,0 +1,4 @@
+export declare function plugin_path(plugin_name: string, config_path: string, preferWasm?: boolean): Promise<{
+    executable: string;
+    directory: string;
+}>;

package/build/lib/plugins.js

@@ -0,0 +1,88 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import * as fs from "./fs.js";
+import * as path from "./path.js";
+async function plugin_path(plugin_name, config_path, preferWasm = false) {
+  if (plugin_name.startsWith("./") || plugin_name.startsWith("../") || path.isAbsolute(plugin_name)) {
+    let executable = path.resolve(path.dirname(config_path), plugin_name);
+    if (fs.existsSync(executable) && fs.statSync(executable).isDirectory()) {
+      executable = path.join(executable, "index.js");
+    }
+    return { executable, directory: path.dirname(executable) };
+  }
+  if (process.versions.pnp) {
+    const { findPnpApi } = require("node:module");
+    const pnp = findPnpApi(config_path);
+    return pnp.resolveRequest(plugin_name, config_path, {
+      conditions: /* @__PURE__ */ new Set(["import"])
+    });
+  }
+  let plugin_dir;
+  try {
+    plugin_dir = find_module(plugin_name, config_path);
+  } catch (e) {
+    throw new Error(
+      `Could not find plugin: ${plugin_name}. Are you sure it's installed? If so, please open a ticket on GitHub. ${e}`
+    );
+  }
+  const package_json_src = await fs.readFile(path.join(plugin_dir, "package.json"));
+  if (!package_json_src) {
+    throw new Error(
+      `Found package '${plugin_name}' but could not read its package.json at ${plugin_dir}.`
+    );
+  }
+  const package_json = JSON.parse(package_json_src);
+  if (!package_json.bin) {
+    throw new Error(
+      `Found package '${plugin_name}' but it has no bin field in its package.json. Houdini plugins are executables \u2014 add a "bin" entry pointing to the plugin's entry point. If this is a local monorepo package, this is the most likely cause.`
+    );
+  }
+  const bin_value = typeof package_json.bin === "string" ? package_json.bin : Object.values(package_json.bin)[0];
+  const native_bin = path.join(plugin_dir, bin_value);
+  if (preferWasm) {
+    try {
+      const wasm_dir = find_module(`${plugin_name}-wasm`, config_path);
+      return {
+        executable: path.join(wasm_dir, "bin", `${plugin_name}.wasm`),
+        directory: plugin_dir
+      };
+    } catch {
+    }
+  }
+  return {
+    executable: native_bin,
+    directory: plugin_dir
+  };
+}
+function find_module(pkg, config_path) {
+  try {
+    const projectRequire = createRequire(pathToFileURL(config_path));
+    const packageJsonPath = projectRequire.resolve(`${pkg}/package.json`);
+    return path.dirname(packageJsonPath);
+  } catch {
+    if (pkg === "houdini-core") {
+      const houdiniRequire = createRequire(import.meta.url);
+      const packageJsonPath = houdiniRequire.resolve(`${pkg}/package.json`);
+      return path.dirname(packageJsonPath);
+    }
+    return find_module_walking_modules(pkg, path.dirname(config_path));
+  }
+}
+function find_module_walking_modules(pkg = "houdini", currentLocation) {
+  const pathEndingBy = ["node_modules", pkg];
+  let found = path.join(currentLocation, ...pathEndingBy);
+  let previous = "";
+  const backFolder = [];
+  while (previous !== found && !fs.existsSync(found)) {
+    previous = found;
+    backFolder.push("../");
+    found = path.join(currentLocation, ...backFolder, ...pathEndingBy);
+  }
+  if (previous === found) {
+    throw new Error(`Could not find any node_modules/${pkg} folder`);
+  }
+  return found;
+}
+export {
+  plugin_path
+};

package/build/lib/project.d.ts

@@ -0,0 +1,19 @@
+import * as graphql from 'graphql';
+import { Config, type ConfigFile } from './config.js';
+export type { ConfigFile } from './config.js';
+export type PluginMeta = {
+    name: string;
+    config: Record<string, any>;
+    executable: string;
+    directory: string;
+};
+export declare const default_config: ConfigFile;
+export declare function get_config({ force_reload, config_path: _config_path, skip_schema, }?: {
+    config_path?: string;
+    force_reload?: boolean;
+    skip_schema?: boolean;
+}): Promise<Config>;
+export declare function load_vite_env(configPath: string): Promise<Record<string, string>>;
+export declare function read_config_file(configPath: string): Promise<ConfigFile>;
+export declare function internal_routes(config: Config): string[];
+export declare function load_local_schema(config: ConfigFile, schema_path: string): Promise<graphql.GraphQLSchema>;