houdini 2.0.0-next.8 → 2.0.0

package/build/adapter/index.d.ts

@@ -1,3 +1,3 @@
-import type { serverAdapterFactory as createAdapter } from '../runtime/router/server';
+import type { serverAdapterFactory as createAdapter } from '../router/server.js';
 export declare const endpoint: string;
-export declare let createServerAdapter: (args: Omit<Parameters<typeof createAdapter>[0], 'on_render' | 'manifest' | 'yoga' | 'schema' | 'graphqlEndpoint' | 'componentCache' | 'client'>) => ReturnType<typeof createAdapter>;
+export declare let createServerAdapter: (args: Omit<Parameters<typeof createAdapter>[0], 'on_render' | 'manifest' | 'yoga' | 'schema' | 'graphqlEndpoint' | 'componentCache' | 'client' | 'config_file'>) => ReturnType<typeof createAdapter>;

package/build/adapter/index.js

@@ -0,0 +1,6 @@
+const endpoint = "";
+let createServerAdapter;
+export {
+  createServerAdapter,
+  endpoint
+};

package/build/cmd/generate.d.ts

@@ -1,3 +1,4 @@
+import { type PipelineHook } from '../lib/index.js';
 export declare function generate(args?: {
     pullSchema: boolean;
     persistOutput?: string;
@@ -5,4 +6,8 @@ export declare function generate(args?: {
     headers: string[];
     log?: string;
     verbose: boolean;
+    mode?: string;
+    preserveDatabase: boolean;
+    afterPhase?: PipelineHook;
+    beforePhase?: PipelineHook;
 }): Promise<void>;

package/build/cmd/generate.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import { format_error } from "../lib/error.js";
+import {
+  codegen_setup,
+  init_db,
+  run_pipeline,
+  PIPELINE_HOOKS
+} from "../lib/index.js";
+import { get_config } from "../lib/project.js";
+import pull_schema from "./pullSchema.js";
+async function generate(args = {
+  pullSchema: false,
+  headers: [],
+  verbose: false,
+  preserveDatabase: false
+}) {
+  const mode = args.mode ?? "development";
+  let on_close = async () => {
+  };
+  if (args.pullSchema) {
+    await pull_schema({ headers: args.headers, output: args.output });
+  }
+  try {
+    const config = await get_config();
+    const [db, dbFilepath] = await init_db(config, args.preserveDatabase);
+    const { trigger_hook, close } = await codegen_setup(config, mode, db, dbFilepath);
+    on_close = async () => {
+      try {
+        await close();
+        process.exit(0);
+      } catch (_error) {
+        process.exit(1);
+      }
+    };
+    process.on("SIGINT", on_close);
+    process.on("SIGTERM", on_close);
+    if (args.afterPhase && !PIPELINE_HOOKS.includes(args.afterPhase)) {
+      throw new Error(
+        `Invalid --after-phase: ${args.afterPhase}. Valid phases are: ${PIPELINE_HOOKS.join(
+          ", "
+        )}`
+      );
+    }
+    if (args.beforePhase && !PIPELINE_HOOKS.includes(args.beforePhase)) {
+      throw new Error(
+        `Invalid --before-phase: ${args.beforePhase}. Valid phases are: ${PIPELINE_HOOKS.join(", ")}`
+      );
+    }
+    const pipelineOptions = {
+      after: "Schema"
+    };
+    if (args.afterPhase) {
+      pipelineOptions.after = args.afterPhase;
+    }
+    if (args.beforePhase) {
+      pipelineOptions.through = args.beforePhase;
+    }
+    const results = await run_pipeline(trigger_hook, pipelineOptions);
+    const docCount = Object.values(results.GenerateDocuments ?? {}).flat().length;
+    console.log(`\u{1F3A9} Generated ${docCount} ${docCount === 1 ? "document" : "documents"}`);
+    await on_close();
+  } catch (e) {
+    format_error(e, (error) => {
+      console.error(error.stack?.split("\n").slice(1).join("\n"));
+    });
+    try {
+      on_close();
+    } catch (closeError) {
+      console.error("Error closing plugins:", closeError);
+    }
+    process.exit(1);
+  }
+}
+export {
+  generate
+};

package/build/cmd/index.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { generate } from "./generate.js";
+import { init } from "./init.js";
+import pullSchema from "./pullSchema.js";
+const program = new Command();
+program.command("generate").description("generate the application runtime").option("-p, --pull-schema", "pull the latest schema before generating").option("-r, --preserve-database", "preserve any existing generated logic").option("-o, --output [outputPath]", "persist queries to a queryMap file").option(
+  "-h, --headers <headers...>",
+  "headers to use when pulling your schema. Should be passed as KEY=VALUE"
+).option("-v, --verbose", "verbose error messages").option(
+  "--after-phase <phase>",
+  "start the pipeline after the specified phase (Config, AfterLoad, Schema, ExtractDocuments, AfterExtract, BeforeValidate, Validate, AfterValidate, BeforeGenerate, GenerateDocuments, GenerateRuntime, AfterGenerate)"
+).option(
+  "--before-phase <phase>",
+  "run the pipeline up to and including the specified phase (Config, AfterLoad, Schema, ExtractDocuments, AfterExtract, BeforeValidate, Validate, AfterValidate, BeforeGenerate, GenerateDocuments, GenerateRuntime, AfterGenerate)"
+).action(generate);
+program.command("init").arguments("[path]").usage("[path] [options]").description("initialize a new houdini project").option(
+  "-h, --headers <headers...>",
+  "header to use when pulling your schema. Should be passed as KEY=VALUE"
+).option("-y, --yes", "dont prompt for input. uses default values or empty strings").action(init);
+program.command("pull-schema").usage("[options]").description("pull the latest schema from your api").option("-o, --output [outputPath]", "the destination for the schema contents").option(
+  "-h, --headers <headers...>",
+  "headers to use when pulling your schema. Should be passed as KEY=VALUE"
+).action(pullSchema);
+program.parse();
+process.on("unhandledRejection", (error) => {
+  if ("description" in error) {
+  } else {
+    console.log(error);
+  }
+});

package/build/cmd/init.js

@@ -0,0 +1,565 @@
+#!/usr/bin/env node
+
+import * as p from "@clack/prompts";
+import { bold, cyan, gray, green, italic } from "kleur/colors";
+import { execSync } from "node:child_process";
+import { fs, path } from "../lib/index.js";
+import { pull_schema } from "../lib/schema.js";
+function pCancel(cancelText = "Operation cancelled.") {
+  p.cancel(cancelText);
+  process.exit(1);
+}
+async function init(_path, args) {
+  p.intro("\u{1F3A9} Welcome to Houdini!");
+  try {
+    await fs.stat(path.resolve("./src"));
+  } catch {
+    throw new Error(
+      "Please initialize your project first before running init. For svelte projects, you should follow the instructions here: https://kit.svelte.dev/"
+    );
+  }
+  const headers = extractHeaders(args.headers);
+  const targetPath = _path ? path.resolve(_path) : process.cwd();
+  let use_git = false;
+  let dir = targetPath;
+  do {
+    if (fs.existsSync(path.join(dir, ".git"))) {
+      use_git = true;
+      break;
+    }
+  } while (dir !== (dir = path.dirname(dir)));
+  if (use_git) {
+    const status = execSync("git status --porcelain", {
+      stdio: "pipe"
+    }).toString();
+    if (status) {
+      const { confirm } = await p.group(
+        {
+          confirm: () => {
+            p.log.warning(
+              `Your git working directory is dirty \u2014 we recommend committing your changes before running this migration.`
+            );
+            return p.confirm({
+              message: `Continue anyway?`,
+              initialValue: false
+            });
+          }
+        },
+        {
+          onCancel: () => pCancel()
+        }
+      );
+      if (confirm !== true) {
+        pCancel();
+      }
+    }
+  }
+  let url = "http://localhost:5173/api/graphql";
+  let is_remote_endpoint = true;
+  if (!args.yes) {
+    is_remote_endpoint = (await p.group(
+      {
+        is_remote_endpoint: () => p.confirm({
+          message: "Will you use a remote GraphQL API?",
+          initialValue: true
+        })
+      },
+      {
+        onCancel: () => pCancel()
+      }
+    )).is_remote_endpoint;
+  }
+  let schemaPath = is_remote_endpoint ? "./schema.graphql" : "path/to/src/lib/**/*.graphql";
+  let pullSchema_content = null;
+  if (is_remote_endpoint && !args.yes) {
+    const { api_running } = await p.group(
+      {
+        api_running: () => p.confirm({
+          message: "Is your API currently running?",
+          initialValue: true
+        })
+      },
+      { onCancel: () => pCancel() }
+    );
+    if (api_running) {
+      let number_of_round = 0;
+      let url_and_headers = "";
+      while (pullSchema_content === null && number_of_round < 10) {
+        number_of_round++;
+        const answer = await p.group(
+          {
+            url_and_headers: async () => p.text({
+              message: `What's the URL for your api? ${number_of_round === 1 ? "" : `(attempt ${number_of_round})`}`,
+              placeholder: `http://localhost:4000/graphql ${number_of_round === 1 ? "" : "Authorization=Bearer MyToken"}`,
+              validate: (value) => {
+                if (value && !value.startsWith("http")) {
+                  return "Please enter a valid URL";
+                }
+              }
+            })
+          },
+          {
+            onCancel: () => pCancel()
+          }
+        );
+        url_and_headers = answer.url_and_headers;
+        const value_splited = url_and_headers.split(" ");
+        const local_url = value_splited[0];
+        const local_headers = value_splited.length > 1 ? extractHeadersStr(value_splited.slice(1).join(" ")) : headers;
+        const fetchTimeout = 3e4;
+        pullSchema_content = await pull_schema(
+          local_url,
+          fetchTimeout,
+          schemaPath,
+          local_headers,
+          true
+        );
+        if (pullSchema_content === null) {
+          const msg = `If you need to pass headers, add them after the URL (eg: '${green(
+            `http://myurl.com/graphql Authorization=Bearer MyToken`
+          )}')`;
+          p.log.error(msg);
+        }
+        url = url_and_headers === "" ? "http://localhost:4000/graphql" : local_url;
+      }
+      if (pullSchema_content === null) {
+        pCancel("We couldn't pull the schema. Please check your URL/headers and try again.");
+      }
+    } else {
+      const { has_schema_file } = await p.group(
+        {
+          has_schema_file: () => p.confirm({
+            message: "Do you have a schema file on disk we can use?",
+            initialValue: false
+          })
+        },
+        { onCancel: () => pCancel() }
+      );
+      if (has_schema_file) {
+        const { schema_file_path } = await p.group(
+          {
+            schema_file_path: () => p.path({
+              message: "Where is the schema file?",
+              initialValue: "./schema.graphql",
+              validate: (value) => {
+                if (!value) return "Please enter a valid path";
+                try {
+                  fs.statSync(path.resolve(value));
+                } catch {
+                  return "File not found";
+                }
+              }
+            })
+          },
+          { onCancel: () => pCancel() }
+        );
+        pullSchema_content = await fs.readFile(path.resolve(schema_file_path)) ?? null;
+      }
+      url = "API_URL";
+    }
+  } else if (!args.yes) {
+    const answers = await p.group(
+      {
+        schema_path: () => p.path({
+          message: "Where is your schema located?",
+          initialValue: schemaPath,
+          validate: (value) => {
+            if (!value) return "Please enter a valid schemaPath";
+          }
+        })
+      },
+      {
+        onCancel: () => pCancel()
+      }
+    );
+    schemaPath = answers.schema_path;
+  }
+  if (is_remote_endpoint && pullSchema_content) {
+    await fs.writeFile(path.join(targetPath, schemaPath), pullSchema_content);
+  }
+  const { frameworkInfo, typescript, module, package_manager } = await detectTools(targetPath);
+  const found_to_log = [];
+  if (frameworkInfo.framework === "svelte") {
+    found_to_log.push("\u2728 Svelte");
+  } else if (frameworkInfo.framework === "kit") {
+    found_to_log.push("\u2728 SvelteKit");
+  } else {
+    throw new Error(`Unmanaged framework: "${JSON.stringify(frameworkInfo)}"`);
+  }
+  if (module === "esm") {
+    found_to_log.push("\u{1F4E6} ES Modules");
+  } else {
+    found_to_log.push("\u{1F4E6} CommonJS");
+  }
+  if (typescript) {
+    found_to_log.push("\u{1F7E6} TypeScript");
+  } else {
+    found_to_log.push("\u{1F7E8} JavaScript");
+  }
+  p.log.info(`Here's what we found: ${found_to_log.join(", ")}`);
+  const sourceDir = path.join(targetPath, "src");
+  const configPath = path.join(targetPath, "houdini.config.js");
+  const s = p.spinner();
+  s.start(`\u{1F6A7} Generating houdini's files...`);
+  const runtimeDir = ".houdini";
+  await houdiniConfig(
+    configPath,
+    schemaPath,
+    module,
+    frameworkInfo,
+    is_remote_endpoint ? url : null,
+    runtimeDir
+  );
+  await houdiniClient(sourceDir, typescript, frameworkInfo, is_remote_endpoint ? url : null);
+  if (frameworkInfo.framework === "svelte") {
+    await svelteKitConfig(targetPath, typescript);
+  } else if (frameworkInfo.framework === "kit") {
+    await svelteConfig(targetPath, typescript);
+  }
+  await gitIgnore({ targetPath, runtimeDir });
+  await graphqlRC(targetPath, runtimeDir);
+  await viteConfig(targetPath, frameworkInfo, typescript);
+  await tjsConfig(targetPath, frameworkInfo);
+  await packageJSON(targetPath, frameworkInfo);
+  s.stop(`Houdini's files generated ${green("\u2713")}`);
+  p.outro("\u{1F389} Everything is ready!");
+  finale_logs(package_manager);
+}
+function finale_logs(package_manager) {
+  let cmd_install = "npm i";
+  let cmd_run = "npm run dev";
+  if (package_manager === "pnpm") {
+    cmd_install = "pnpm i";
+    cmd_run = "pnpm dev";
+  } else if (package_manager === "yarn") {
+    cmd_install = "yarn";
+    cmd_run = "yarn dev";
+  }
+  console.log(`\u{1F449} Next Steps`);
+  console.log(`1  Finalize your installation: ${green(cmd_install)}
+2  Start your application:     ${green(cmd_run)}
+`);
+  console.log(
+    gray(
+      italic(
+        `${bold("\u2754 More help")} at ${cyan(
+          "https://houdinigraphql.com"
+        )} (\u{1F4C4} Docs, \u2B50 Github, \u{1F4E3} Discord, ...)
+`
+      )
+    )
+  );
+}
+async function houdiniConfig(configPath, schemaPath, module, frameworkInfo, url, runtimeDir) {
+  const config = {};
+  const URL_SENTINEL = "__HOUDINI_URL_EXPR__";
+  if (url !== null) {
+    config.url = URL_SENTINEL;
+  }
+  config.runtimeDir = runtimeDir;
+  if (url !== null) {
+    config.schemaPath = schemaPath;
+  }
+  if (module !== "esm") {
+    config.module = module;
+  }
+  if (frameworkInfo.framework === "svelte") {
+    config.plugins = {
+      "houdini-svelte": {
+        framework: "svelte"
+      }
+    };
+  } else if (frameworkInfo.framework === "kit") {
+    config.plugins = {
+      "houdini-svelte": {}
+    };
+  }
+  let configObj = JSON.stringify(config, null, 4);
+  if (url !== null) {
+    const urlExpr = module === "esm" ? `import.meta.env.VITE_API_URL ?? ${JSON.stringify(url)}` : `process.env.VITE_API_URL ?? ${JSON.stringify(url)}`;
+    configObj = configObj.replace(`"${URL_SENTINEL}"`, urlExpr);
+  }
+  const content_base = `/// <references types="houdini-svelte">
+
+/** @type {import('houdini').ConfigFile} */
+const config = ${configObj}`;
+  const content = module === "esm" ? (
+    // ESM default config
+    `${content_base}
+
+export default config
+`
+  ) : (
+    // CommonJS default config
+    `${content_base}
+
+module.exports = config
+`
+  );
+  await fs.writeFile(configPath, content);
+  return false;
+}
+async function houdiniClient(targetPath, typescript, _frameworkInfo, _url) {
+  const houdiniClientExt = typescript ? `ts` : `js`;
+  const houdiniClientPath = path.join(targetPath, `client.${houdiniClientExt}`);
+  const comment = `
+    // uncomment this to configure the network call (for things like authentication)
+    // for more information, please visit here: https://www.houdinigraphql.com/guides/authentication
+    // fetchParams({ session }) {
+    //     return {
+    //         headers: {
+    //             Authorization: \`Bearer \${session.token}\`,
+    //         }
+    //     }
+    // }`;
+  const content = `import { HoudiniClient } from '$houdini';
+
+export default new HoudiniClient({${comment}
+})
+`;
+  await fs.writeFile(houdiniClientPath, content);
+}
+async function svelteKitConfig(targetPath, typescript) {
+  const svelteMainJsPath = path.join(targetPath, "src", typescript ? "main.ts" : "main.js");
+  const newContent = `import client from "./client";
+import './app.css'
+import App from './App.svelte'
+
+const app = new App({
+	target: document.getElementById('app')
+})
+
+export default app
+`;
+  await fs.writeFile(svelteMainJsPath, newContent);
+}
+async function svelteConfig(targetPath, typescript) {
+  const svelteConfigPath = path.join(targetPath, "svelte.config.js");
+  const newContentTs = `import adapter from '@sveltejs/adapter-auto';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+	// Consult https://kit.svelte.dev/docs/integrations#preprocessors
+	// for more information about preprocessors
+	preprocess: vitePreprocess(),
+
+	kit: {
+		adapter: adapter(),
+		alias: {
+			$houdini: '.houdini/'
+		}
+	}
+};
+
+export default config;
+`;
+  const newContentJs = `import adapter from '@sveltejs/adapter-auto';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+	kit: {
+		adapter: adapter(),
+		alias: {
+			$houdini: '.houdini/'
+		}
+	}
+};
+
+export default config;
+`;
+  await fs.writeFile(svelteConfigPath, typescript ? newContentTs : newContentJs);
+}
+async function gitIgnore({ targetPath, runtimeDir }) {
+  const filepath = path.join(targetPath, ".gitignore");
+  const existing = await fs.readFile(filepath) || "";
+  if (!existing.includes(`
+${runtimeDir}
+`)) {
+    await fs.writeFile(filepath, `${existing}
+${runtimeDir}
+`);
+  }
+}
+async function graphqlRC(targetPath, runtimeDir) {
+  const target = path.join(targetPath, ".graphqlrc.yaml");
+  const content = `projects:
+  default:
+    schema:
+      - ./schema.graphql
+      - ./${runtimeDir}/graphql/schema.graphql
+    documents:
+      - '**/*.gql'
+      - '**/*.svelte'
+      - ./${runtimeDir}/graphql/documents.gql
+`;
+  await fs.writeFile(target, content);
+}
+async function viteConfig(targetPath, frameworkInfo, typescript) {
+  const viteConfigPath = path.join(targetPath, typescript ? "vite.config.ts" : "vite.config.js");
+  let content = "NO_CONTENT_THIS_SHOULD_NEVER_BE_SEEN";
+  if (frameworkInfo.framework === "svelte") {
+    content = `import { svelte } from '@sveltejs/vite-plugin-svelte'
+import houdini from 'houdini/vite'
+import * as path from 'path'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+	plugins: [houdini(), svelte()],
+
+	resolve: {
+		alias: {
+			$houdini: '.houdini/',
+		},
+	},
+})
+	`;
+  } else if (frameworkInfo.framework === "kit") {
+    content = `import { sveltekit } from '@sveltejs/kit/vite'
+import houdini from 'houdini/vite'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+	plugins: [houdini(), sveltekit()]
+});
+`;
+  } else {
+    throw new Error(`Unmanaged framework: "${JSON.stringify(frameworkInfo)}"`);
+  }
+  await fs.writeFile(viteConfigPath, content);
+}
+async function tjsConfig(targetPath, frameworkInfo) {
+  let configFile = path.join(targetPath, "tsconfig.json");
+  try {
+    await fs.stat(configFile);
+  } catch {
+    configFile = path.join(targetPath, "jsconfig.json");
+    try {
+      await fs.stat(configFile);
+    } catch {
+      return false;
+    }
+  }
+  let tjsConfig2;
+  try {
+    const tjsConfigFile = await fs.readFile(configFile);
+    if (tjsConfigFile) {
+      tjsConfig2 = parseJSON(tjsConfigFile);
+    }
+    if (frameworkInfo.framework === "svelte") {
+      tjsConfig2.compilerOptions.rootDirs = [".", "./.houdini/types"];
+    } else if (frameworkInfo.framework === "kit") {
+      tjsConfig2.compilerOptions.rootDirs = [".", "./.svelte-kit/types", "./.houdini/types"];
+    }
+    if (frameworkInfo.framework === "svelte") {
+      tjsConfig2.compilerOptions.paths = {
+        ...tjsConfig2.compilerOptions.paths,
+        $houdini: ["./.houdini/"],
+        "$houdini/*": ["./.houdini/*"]
+      };
+    }
+    await fs.writeFile(configFile, JSON.stringify(tjsConfig2, null, 4));
+  } catch {
+  }
+  return false;
+}
+async function packageJSON(targetPath, frameworkInfo) {
+  let packageJSON2 = {};
+  const packagePath = path.join(targetPath, "package.json");
+  const packageFile = await fs.readFile(packagePath);
+  if (packageFile) {
+    packageJSON2 = JSON.parse(packageFile);
+  }
+  packageJSON2.devDependencies = {
+    ...packageJSON2.devDependencies,
+    houdini: "^2.0.0"
+  };
+  if (frameworkInfo.framework === "svelte" || frameworkInfo.framework === "kit") {
+    packageJSON2.devDependencies = {
+      ...packageJSON2.devDependencies,
+      "houdini-svelte": "^3.0.0"
+    };
+  } else {
+    throw new Error(`Unmanaged framework: "${JSON.stringify(frameworkInfo)}"`);
+  }
+  await fs.writeFile(packagePath, JSON.stringify(packageJSON2, null, 4));
+}
+async function detectFromPackageJSON(cwd) {
+  let packageJSON2;
+  try {
+    const packageJSONFile = await fs.readFile(path.join(cwd, "package.json"));
+    if (packageJSONFile) {
+      packageJSON2 = JSON.parse(packageJSONFile);
+    } else {
+      throw new Error("not found");
+    }
+  } catch {
+    throw new Error(
+      "\u274C houdini init must target an existing node project (with a package.json)"
+    );
+  }
+  const { devDependencies, dependencies } = packageJSON2;
+  const hasDependency = (dep) => Boolean(devDependencies?.[dep] || dependencies?.[dep]);
+  let frameworkInfo = { framework: "svelte" };
+  if (hasDependency("@sveltejs/kit")) {
+    frameworkInfo = { framework: "kit" };
+  }
+  return {
+    frameworkInfo,
+    module: packageJSON2.type === "module" ? "esm" : "commonjs"
+  };
+}
+async function detectTools(cwd = process.cwd()) {
+  let typescript = false;
+  try {
+    await fs.stat(path.join(cwd, "tsconfig.json"));
+    typescript = true;
+  } catch {
+  }
+  let package_manager = "npm";
+  let dir = cwd;
+  do {
+    if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) {
+      package_manager = "pnpm";
+      break;
+    }
+    if (fs.existsSync(path.join(dir, "yarn.lock"))) {
+      package_manager = "yarn";
+      break;
+    }
+  } while (dir !== (dir = path.dirname(dir)));
+  return {
+    typescript,
+    package_manager,
+    ...await detectFromPackageJSON(cwd)
+  };
+}
+function parseJSON(str) {
+  str = str.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m);
+  return JSON.parse(str);
+}
+function extractHeadersStr(str) {
+  const regex = /(\w+)=("[^"]*"|[^ ]*)/g;
+  const obj = {};
+  let match;
+  while ((match = regex.exec(str ?? "")) !== null) {
+    obj[match[1]] = match[2].replaceAll('"', "");
+  }
+  return obj;
+}
+function extractHeaders(headers) {
+  if ((headers ?? []).length > 0) {
+    return headers.reduce((total, header) => {
+      const [key, value] = header.split(/=(.*)/s);
+      return {
+        ...total,
+        [key]: value.replaceAll('"', "")
+      };
+    }, {});
+  }
+  return {};
+}
+export {
+  finale_logs,
+  init
+};