nuxt-surrealdb/dist/module.mjs

A Nuxt module aimed to simplify the use of SurrealDB

import { defineNuxtModule, createResolver, addPlugin, addImports, addServerImports, addServerPlugin, addImportsSources } from '@nuxt/kit';
import { resolveModulePath } from 'exsolve';
import { defu } from 'defu';

const module$1 = defineNuxtModule({
  meta: {
    name: "surrealdb",
    configKey: "surrealdb",
    compatibility: {
      nuxt: "^3.21.0 || ^4.3.0"
    }
  },
  setup(options, nuxt) {
    const { resolve } = createResolver(import.meta.url);
    const runtimeDir = resolve("./runtime");
    nuxt.options.alias["#surrealdb"] = runtimeDir;
    const runtimeConfig = nuxt.options.runtimeConfig || {};
    const publicRuntimeConfig = runtimeConfig.public || {};
    const [wasmModule, nodeModule] = [
      tryImport("@surrealdb/wasm"),
      tryImport("@surrealdb/node")
    ];
    const defConnOpts = {
      namespace: "",
      database: ""
    };
    publicRuntimeConfig.surrealdb = defu(
      publicRuntimeConfig.surrealdb,
      options.client,
      {
        endpoint: "",
        connectOptions: defConnOpts,
        preferHttp: true,
        autoConnect: true,
        memory: wasmModule ? {
          connectOptions: defConnOpts
        } : void 0,
        local: wasmModule ? {
          connectOptions: defConnOpts
        } : void 0
      }
    );
    runtimeConfig.surrealdb = defu(
      runtimeConfig.surrealdb,
      options.server,
      {
        session: "new",
        preferHttp: true,
        autoConnect: true,
        memory: nodeModule ? {
          session: "new",
          connectOptions: defConnOpts
        } : void 0,
        local: nodeModule ? {
          session: "new",
          endpoint: "",
          connectOptions: defConnOpts
        } : void 0
      }
    );
    nuxt.options.vite ||= {};
    nuxt.options.vite.optimizeDeps ||= {};
    nuxt.options.vite.optimizeDeps.exclude ||= [];
    nuxt.options.vite.optimizeDeps.exclude.push("@surrealdb/wasm");
    nuxt.options.vite.optimizeDeps.include ||= [];
    nuxt.options.vite.optimizeDeps.include.push("surrealdb");
    const imports = [];
    const serverImports = [];
    if (options.disableWasmEngine !== true && wasmModule === true) {
      imports.push(
        {
          from: resolve(runtimeDir, "app", "composables", "surreal-local"),
          name: "useSurrealLocal"
        },
        {
          from: resolve(runtimeDir, "app", "composables", "surreal-memory"),
          name: "useSurrealMemory",
          as: "useSurrealMemory"
        },
        {
          from: resolve(runtimeDir, "app", "composables", "surreal-memory"),
          name: "useSurrealMemory",
          as: "useSurrealMem"
        }
      );
      addPlugin(resolve(runtimeDir, "app", "plugins", "memory.server"));
      addPlugin(resolve(runtimeDir, "app", "plugins", "memory.client"));
      addPlugin(resolve(runtimeDir, "app", "plugins", "local.server"));
      addPlugin(resolve(runtimeDir, "app", "plugins", "local.client"));
    }
    if (options.disableNodeEngine !== true && nodeModule === true) {
      serverImports.push(
        {
          from: resolve(runtimeDir, "server", "utils", "surreal-local"),
          name: "useSurrealLocal"
        },
        {
          from: resolve(runtimeDir, "server", "utils", "surreal-memory"),
          name: "useSurrealMemory",
          as: "useSurrealMemory"
        },
        {
          from: resolve(runtimeDir, "server", "utils", "surreal-memory"),
          name: "useSurrealMemory",
          as: "useSurrealMem"
        }
      );
    }
    imports.push(
      {
        from: resolve(runtimeDir, "app", "composables", "surreal"),
        name: "useSurreal"
      },
      {
        from: resolve(runtimeDir, "app", "composables", "surreal-hooks"),
        name: "surrealHooks"
      },
      ...[
        "useSurrealAsyncData",
        "useSurrealAuth",
        "useSurrealExport",
        "useSurrealImport",
        "useSurrealQuery",
        "useSurrealRun",
        "useSurrealSelect",
        "useSurrealVersion"
      ].map((c) => ({
        from: resolve(runtimeDir, "app", "composables", "ssr-safe"),
        name: c
      }))
    );
    const ssrSafeSource = resolve(runtimeDir, "app", "composables", "ssr-safe");
    nuxt.options.optimization ||= {};
    nuxt.options.optimization.keyedComposables ||= [];
    nuxt.options.optimization.keyedComposables.push(
      { name: "useSurrealAsyncData", source: ssrSafeSource, argumentLength: 3 },
      { name: "useSurrealAuth", source: ssrSafeSource, argumentLength: 2 },
      { name: "useSurrealExport", source: ssrSafeSource, argumentLength: 3 },
      { name: "useSurrealImport", source: ssrSafeSource, argumentLength: 3 },
      { name: "useSurrealQuery", source: ssrSafeSource, argumentLength: 4 },
      { name: "useSurrealRun", source: ssrSafeSource, argumentLength: 4 },
      { name: "useSurrealSelect", source: ssrSafeSource, argumentLength: 4 },
      { name: "useSurrealVersion", source: ssrSafeSource, argumentLength: 2 }
    );
    serverImports.push(
      {
        from: resolve(runtimeDir, "server", "utils", "surreal"),
        name: "useSurreal"
      },
      {
        from: resolve(runtimeDir, "server", "utils", "surreal-hooks"),
        name: "surrealHooks"
      }
    );
    addImports(imports);
    addPlugin(resolve(runtimeDir, "app", "plugins", "surreal"));
    addServerImports(serverImports);
    addServerPlugin(resolve(runtimeDir, "server", "plugins", "clear"));
    if (options.autoImport !== false) {
      const names = [
        "Uuid",
        "RecordId",
        "StringRecordId",
        "BoundIncluded",
        "BoundExcluded",
        "RecordIdRange",
        "Duration",
        "Decimal",
        "Table",
        "Geometry",
        "GeometryPoint",
        "GeometryLine",
        "GeometryPolygon",
        "GeometryMultiPoint",
        "GeometryMultiLine",
        "GeometryMultiPolygon",
        "GeometryCollection",
        "Surreal"
      ];
      addImportsSources({
        from: "surrealdb",
        imports: names
      });
      addServerImports(
        names.map((n) => ({
          from: "surrealdb",
          name: n
        }))
      );
      if (options.autoImportExpressions) {
        const exprNames = [
          "expr",
          "raw",
          "eq",
          "eeq",
          "gt",
          "gte",
          "lt",
          "lte",
          "contains",
          "containsAll",
          "containsAny",
          "containsNone",
          "inside",
          "outside",
          "intersects",
          "matches",
          "knn",
          "between",
          "and",
          "or",
          "not"
        ];
        addImportsSources({
          from: "surrealdb",
          imports: exprNames
        });
        addServerImports(
          exprNames.map((n) => ({
            from: "surrealdb",
            name: n
          }))
        );
      }
    }
  }
});
function tryImport(pkg) {
  try {
    const m = resolveModulePath(pkg, { from: import.meta.url });
    return typeof m === "string" && m.length > 0;
  } catch {
    return false;
  }
}

export { module$1 as default };