silgi 0.3.13 → 0.4.0

package/dist/cli/prepare.mjs

@@ -0,0 +1,1346 @@
+import { defineCommand } from 'citty';
+import { join, resolve, isAbsolute, relative, dirname, basename, extname } from 'pathe';
+import { version } from 'silgi/meta';
+import { runtimeDir } from 'silgi/runtime/meta';
+import fsp, { readdir } from 'node:fs/promises';
+import { promises, existsSync, readFileSync } from 'node:fs';
+import { createJiti } from 'jiti';
+import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolve as resolve$1 } from 'mlly';
+import { resolveAlias } from 'pathe/utils';
+import { silgiGenerateType, SchemaParser, loadOptions } from 'silgi/core';
+import { relativeWithDot, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1 } from 'silgi/kit';
+import { toExports, createUnimport } from 'unimport';
+import { readPackageJSON } from 'pkg-types';
+import { hash } from 'ohash';
+import { consola } from 'consola';
+import { createHooks, createDebugger } from 'hookable';
+import { join as join$1 } from 'node:path';
+import { makeExecutableSchema, mergeSchemas } from '@graphql-tools/schema';
+import { printSchemaWithDirectives } from '@graphql-tools/utils';
+import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
+import { loadSchemaSync } from '@graphql-tools/load';
+import { pascalCase } from 'scule';
+import { h as hasInstalledModule, u as useSilgiCLI, s as silgiCLICtx } from './compatibility.mjs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { isRelative, withTrailingSlash } from 'ufo';
+import { globby } from 'globby';
+import ignore from 'ignore';
+import { klona } from 'klona';
+import { createStorage, builtinDrivers } from 'unstorage';
+import 'semver/functions/satisfies.js';
+import 'unctx';
+
+async function h3Framework(silgi, skip = false) {
+  if (silgi.options.preset !== "h3" && skip === false)
+    return;
+  if (silgi.options.preset === "h3") {
+    silgi.hook("prepare:schema.ts", (data) => {
+      data.importItems.nitropack = {
+        import: [
+          { name: "NitroApp", type: true }
+        ],
+        from: "nitropack/types"
+      };
+    });
+    silgi.hook("after:prepare:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = NitroApp");
+    });
+  }
+  silgi.hook("prepare:createDTSFramework", (data) => {
+    data.importItems["silgi/types"] = {
+      import: [
+        { name: "SilgiModuleContext", type: true }
+      ],
+      from: "silgi/types"
+    };
+    data.customContent?.push(
+      "",
+      'declare module "h3" {',
+      "  interface H3EventContext extends SilgiModuleContext {}",
+      "}",
+      ""
+    );
+  });
+}
+
+async function nitroFramework(silgi, skip = false) {
+  if (silgi.options.preset !== "nitro" && skip === false)
+    return;
+  silgi.hook("prepare:schema.ts", (data) => {
+    data.importItems.nitropack = {
+      import: [
+        { name: "NitroApp", type: true }
+      ],
+      from: "nitropack/types"
+    };
+  });
+  silgi.hook("after:prepare:schema.ts", (data) => {
+    data.unshift("type FrameworkContextExtends = NitroApp");
+  });
+  silgi.options.plugins.push({
+    packageImport: "silgi/runtime/internal/nitro",
+    path: join(runtimeDir, "internal/nitro")
+  });
+  await h3Framework(silgi, true);
+}
+
+const frameworkSetup = [h3Framework, nitroFramework];
+
+async function prepare$1(silgi) {
+  await prepareDir(silgi.options.output.dir);
+  if (!silgi.options.static) {
+    await prepareDir(silgi.options.output.serverDir);
+  }
+}
+async function prepareDir(dir) {
+  await fsp.rm(dir, { recursive: true, force: true });
+  await fsp.mkdir(dir, { recursive: true });
+}
+
+async function readCoreFile(silgi) {
+  const path = resolve(silgi.options.silgi.serverDir, "core.ts");
+  const jiti = createJiti(silgi.options.rootDir, {
+    fsCache: false,
+    interopDefault: true,
+    moduleCache: false,
+    alias: silgi.options.alias
+  });
+  const resolvedPath = jiti.esmResolve(path);
+  const context = await promises.readFile(path, { encoding: "utf-8" });
+  const coreFile = await jiti.import(
+    resolvedPath,
+    {
+      conditions: silgi.options.conditions
+    }
+  );
+  silgi.uris = coreFile.uris;
+  silgi.schemas = coreFile.schemas;
+  silgi.services = coreFile.services;
+  silgi.shareds = coreFile.shareds;
+  silgi.modulesURIs = coreFile.modulesURIs;
+  return {
+    context,
+    object: {
+      schemas: coreFile.schemas,
+      uris: coreFile.uris,
+      services: coreFile.services,
+      shareds: coreFile.shareds,
+      modulesURIs: coreFile.modulesURIs
+    },
+    path
+  };
+}
+
+function traverseObject(silgi, obj, currentPath = []) {
+  const uriMap = /* @__PURE__ */ new Map();
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let paramString = "";
+      if (node.router) {
+        let params = null;
+        if (node.router?._def?.typeName !== undefined) {
+          try {
+            const shape = node.router?.shape?.params?.shape;
+            params = shape ? Object.keys(shape) : null;
+          } catch {
+            params = null;
+          }
+        }
+        if (params?.length) {
+          paramString = params.map((p) => `:${p}`).join("/");
+        }
+      }
+      uriMap.set(basePath, paramString);
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(obj, currentPath);
+  return uriMap;
+}
+function scanActionModulesUris(silgi, obj, currentPath = []) {
+  const uriMap = {};
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let moduleName = "";
+      if (node.modules?.graphqlyoga) {
+        let rootFieldName = null;
+        if (node.modules?.graphqlyoga?.rootFieldName) {
+          moduleName = "graphqlyoga";
+          rootFieldName = node.modules?.graphqlyoga?.rootFieldName;
+        }
+        if (!rootFieldName) {
+          return;
+        }
+        uriMap[moduleName] ??= {};
+        uriMap[moduleName].rootFieldName ??= {};
+        uriMap[moduleName].rootFieldName[rootFieldName] = basePath;
+      }
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(obj, currentPath);
+  return uriMap;
+}
+
+async function scanUris(silgi) {
+  const { context, object, path } = await readCoreFile(silgi);
+  const uriMap = traverseObject(silgi, object.schemas, []);
+  const modulesURIs = scanActionModulesUris(silgi, object.services, []);
+  const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
+  let newContext = "";
+  if (uriMap.size > 0) {
+    newContext = context.replace(
+      /export const uris = \{[^}]*\}/,
+      `export const uris = {
+${uriContent}
+}`
+    ).replace(
+      /export const modulesURIs = \{[^}]*\}/,
+      `export const modulesURIs = ${JSON.stringify(modulesURIs, null, 2)}`
+    );
+  } else {
+    newContext = context;
+  }
+  await promises.writeFile(path, newContext);
+}
+
+async function generateSilgiStorageBaseType(silgi) {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    if (silgi.options.storage) {
+      for (const [key, _value] of Object.entries(silgi.options.storage)) {
+        options.storeBase.push(key);
+      }
+    }
+  });
+}
+
+async function generateRouterDTS(silgi) {
+  silgi.hook("read:core.ts", async (data) => {
+    silgi.hook("close", async () => {
+      const { object } = await data();
+      const uris = object.uris;
+      const tag = "srn";
+      const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _value]) => {
+        const [service, resource, method, action] = key.split("/");
+        const routePath = `${tag}/${service}/${resource}/${action}`;
+        if (!acc[routePath]) {
+          acc[routePath] = {};
+        }
+        acc[routePath][method] = {
+          input: `ExtractInputFromURI<'${key}'>`,
+          output: `ExtractOutputFromURI<'${key}'>`,
+          params: `ExtractRouterParamsFromURI<'${key}'>['params']`
+        };
+        return acc;
+      }, {});
+      const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
+        const methodEntries = Object.entries(methods).map(([method, { input, output, params }]) => {
+          return `    '${method}': {
+      input: ${input},
+      output: ${output}
+      params: ${params}
+    }`;
+        }).join(",\n");
+        return `  '/${path}': {
+${methodEntries}
+  }`;
+      });
+      const nitro = [
+        "declare module 'nitropack/types' {",
+        "  interface InternalApi extends RouterTypes {}",
+        "}"
+      ];
+      const context = [
+        "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractRouterParamsFromURI } from 'silgi/types'",
+        "",
+        "export interface RouterTypes {",
+        routerTypes.join(",\n"),
+        "}",
+        "",
+        "declare module 'silgi/types' {",
+        "  interface SilgiRouterTypes extends RouterTypes {",
+        "  }",
+        "}",
+        "",
+        silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
+        "",
+        "export {}"
+      ].join("\n");
+      const outputPath = resolve(silgi.options.build.typesDir, "silgi-routes.d.ts");
+      await promises.writeFile(outputPath, context);
+    });
+  });
+}
+
+async function createCoreFramework(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  if (silgi.options.preset !== "nitro" && silgi.options.preset !== "h3")
+    return;
+  const importItems = {
+    "silgi": {
+      import: [
+        { name: "useSilgi" }
+      ],
+      from: "silgi"
+    },
+    "silgi/types": {
+      import: [
+        { name: "SilgiModuleContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const functions = [];
+  await silgi.callHook("prepare:createCoreFramework", {
+    importItems,
+    customImports,
+    functions
+  });
+  const content = [
+    ...functions.map((f) => `  ${f}(framework)`)
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+async function createDTSFramework(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  const importItems = {
+    "silgi/types": {
+      import: [
+        { name: "SilgiModuleContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const customContent = [];
+  await silgi.callHook("prepare:createDTSFramework", {
+    importItems,
+    customImports,
+    customContent
+  });
+  const content = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...customImports,
+    "",
+    ...customContent,
+    ""
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+
+async function schemaTemplate(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  const importItems = {
+    "silgi/types": {
+      import: [
+        { name: "URIsTypes", type: true },
+        { name: "Namespaces", type: true },
+        { name: "SilgiModuleContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const configs = [];
+  const contexts = [];
+  const methods = [];
+  const shareds = [];
+  const events = [];
+  const storeBase = [];
+  await silgi.callHook("prepare:schema.ts", {
+    importItems,
+    customImports,
+    configs,
+    contexts,
+    methods,
+    shareds,
+    storeBase,
+    events
+  });
+  const silgiExport = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
+  let addSilgiContext = false;
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...customImports,
+    ""
+  ];
+  const importData = [
+    "interface InferredNamespaces {",
+    ...(silgi.options.namespaces || []).map((key) => `  ${key}: string,`),
+    "}",
+    "",
+    `type SchemaExtends = Namespaces<typeof import('${silgiExport}')['schemas']>`,
+    "",
+    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiExport}')['uris']>`,
+    "",
+    contexts.length ? `type SilgiModuleContextExtends = ${contexts.map(({ value }) => value).join(" & ")}` : "type SilgiModuleContextExtends = {}",
+    "",
+    events.length ? `interface SilgiModuleEventsExtends extends ${events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${events.map((item) => {
+      if (item.isSilgiContext) {
+        addSilgiContext = true;
+      }
+      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiModuleContext" : "";
+    }).join(",\n")}
+}` : "interface SilgiModuleEventsExtends {}",
+    "",
+    shareds.length ? `type SilgiModuleSharedExtends = ${shareds.map(({ value }) => value).join(" & ")}` : "type SilgiModuleSharedExtends = {}",
+    "",
+    "interface SilgiModuleMethodsExtends {",
+    ...(methods).map(({ key, value }) => `  ${key}: ${value},`),
+    "}",
+    "",
+    "interface SilgiModuleOptionsExtends {",
+    ...(configs).map(({ key, value }) => `  ${key}: ${value},`),
+    "}",
+    "",
+    "interface SilgiStorageBaseExtends {",
+    ...(storeBase).map((value) => `  ${value}: ''`),
+    "}",
+    "",
+    "",
+    "declare module 'silgi/types' {",
+    " interface FrameworkContext extends FrameworkContextExtends {}",
+    " interface SilgiSchema extends SchemaExtends {}",
+    " interface SilgiNamespaces extends InferredNamespaces {}",
+    " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
+    " interface SilgiModules extends SilgiModuleOptionsExtends {}",
+    " interface SilgiURIs extends SilgiURIsMerge {}",
+    " interface SilgiModuleContext extends SilgiModuleContextExtends {}",
+    " interface SilgiEvent extends SilgiModuleEventsExtends {}",
+    " interface SilgiDefaultShared extends SilgiModuleSharedExtends {}",
+    " interface SilgiModuleMethods extends SilgiModuleMethodsExtends {}",
+    " interface SilgiModuleOptions extends SilgiModuleOptionsExtends {}",
+    "}",
+    "",
+    "export {}"
+  ];
+  await silgi.callHook("after:prepare:schema.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+async function silgiCoreFile(_importItems, frameworkContext, silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  const importItems = {
+    "silgi/core": {
+      import: [
+        { name: "createSilgi" }
+      ],
+      from: "silgi/core"
+    },
+    "silgi/types": {
+      import: [
+        { name: "SilgiModuleOptions", type: true },
+        { name: "SilgiOptions", type: true },
+        { name: "FrameworkContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  _importItems = { ..._importItems, ...importItems };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const uris = [];
+  const services = [];
+  const shareds = [];
+  const schemas = [];
+  const buildSilgiExtraContent = [];
+  await silgi.callHook("prepare:core.ts", {
+    importItems,
+    customImports,
+    uris,
+    services,
+    shareds,
+    schemas,
+    buildSilgiExtraContent
+  });
+  if (services.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeServices" });
+  }
+  if (shareds.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeShared" });
+  }
+  if (schemas.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeSchemas" });
+  }
+  const plugins = [];
+  for (const plugin of silgi.options.plugins) {
+    const pluginImportName = `_${hash(plugin.packageImport)}`;
+    customImports.push(`import ${pluginImportName} from '${plugin.packageImport}';`);
+    plugins.push(pluginImportName);
+  }
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
+    }),
+    ...customImports,
+    ""
+  ];
+  const importData = [
+    "export const uris = {}",
+    "",
+    "export const modulesURIs = {}",
+    "",
+    schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
+    ...schemas.map((name) => {
+      return `  ${name},`;
+    }),
+    schemas.length > 0 ? "])" : "}",
+    "",
+    services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
+    ...services.map((name) => {
+      return `  ${name},`;
+    }),
+    services.length > 0 ? "])" : "}",
+    "",
+    shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
+    ...shareds.map((name) => {
+      return `  ${name},`;
+    }),
+    shareds.length > 0 ? "])" : "}",
+    "",
+    "export const silgiOptions: Partial<SilgiOptions> = {}",
+    "",
+    "export async function buildSilgi(framework: FrameworkContext, options?: Partial<SilgiModuleOptions>) {",
+    "  const silgi = await createSilgi({",
+    "      framework,",
+    "      shared: shareds as any,",
+    "      services: services as any,",
+    "      schemas: schemas as any,",
+    "      uris,",
+    "      modulesURIs,",
+    `      plugins: [${plugins.join(", ")}],`,
+    "",
+    "      options: {",
+    "      ...silgiOptions,",
+    "      ...options,",
+    "     },",
+    "    })",
+    "",
+    ...frameworkContext,
+    "",
+    ...buildSilgiExtraContent,
+    "",
+    "  return silgi",
+    "}",
+    ""
+  ];
+  await silgi.callHook("after:prepare:core.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+async function writeTypesAndFiles(silgi) {
+  const data = await createCoreFramework(silgi);
+  await generateSilgiStorageBaseType(silgi);
+  await generateRouterDTS(silgi);
+  silgi.hook("prepare:types", (opts) => {
+    opts.references.push({ path: "./schema.d.ts" });
+    opts.references.push({ path: "./silgi-routes.d.ts" });
+    opts.references.push({ path: "./framework.d.ts" });
+  });
+  const schemaContent = await schemaTemplate(silgi);
+  const coreContent = await silgiCoreFile(data?.importItems ?? {}, data?.content ?? [], silgi);
+  const frameworkDTS = await createDTSFramework(silgi);
+  const { declarations, tsConfig } = await silgiGenerateType(silgi);
+  const tsConfigPath = resolve(
+    silgi.options.typescript.generateTsConfig ? silgi.options.build.dir : silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const typesDir = resolve(silgi.options.build.typesDir);
+  const silgiDir = resolve(silgi.options.silgi.serverDir);
+  let autoImportedTypes = [];
+  let autoImportExports = "";
+  if (silgi.unimport) {
+    await silgi.unimport.init();
+    const allImports = await silgi.unimport.getImports();
+    autoImportExports = toExports(allImports).replace(
+      /#internal\/nitro/g,
+      relative(typesDir, runtimeDir)
+    );
+    const resolvedImportPathMap = /* @__PURE__ */ new Map();
+    for (const i of allImports.filter((i2) => !i2.type)) {
+      if (resolvedImportPathMap.has(i.from)) {
+        continue;
+      }
+      let path = resolveAlias(i.from, silgi.options.alias);
+      if (isAbsolute(path)) {
+        const resolvedPath = await resolvePath(i.from, {
+          url: silgi.options.nodeModulesDirs
+        }).catch(() => null);
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(i.from, path);
+    }
+    autoImportedTypes = [
+      silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
+      })).trim() : ""
+    ];
+  }
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "silgi-routes.d.ts"),
+    // contents: uris.join('\n'),
+    contents: ""
+  });
+  buildFiles.push({
+    path: join(silgiDir, "core.ts"),
+    contents: coreContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "schema.d.ts"),
+    contents: schemaContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi.d.ts"),
+    contents: declarations.join("\n")
+  });
+  buildFiles.push({
+    path: tsConfigPath,
+    contents: JSON.stringify(tsConfig, null, 2)
+  });
+  buildFiles.push({
+    path: join(typesDir, "framework.d.ts"),
+    contents: frameworkDTS.content.join("\n")
+  });
+  await Promise.all(
+    buildFiles.map(async (file) => {
+      await writeFile(
+        resolve(silgi.options.build.dir, file.path),
+        file.contents
+      );
+    })
+  );
+}
+
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  },
+  _dir: {
+    type: "positional",
+    default: ".",
+    description: "project root directory (prefer using `--dir`)"
+  }
+};
+
+async function graphQLLoadSchemaSync(schemaPointers, data = {}) {
+  let result;
+  try {
+    result = loadSchemaSync(schemaPointers, {
+      ...data,
+      loaders: [
+        new GraphQLFileLoader(),
+        ...data.loaders || []
+      ]
+    });
+  } catch (e) {
+    if (
+      // https://www.graphql-tools.com/docs/documents-loading#no-files-found
+      (e.message || "").includes(
+        "Unable to find any GraphQL type definitions for the following pointers:"
+      )
+    ) ; else {
+      throw e;
+    }
+  }
+  return result;
+}
+
+async function graphqlLoadSync(silgi) {
+  const typeDefs = [];
+  const resolvers = [];
+  await silgi.callHook("before:graphql:schema", {
+    typeDefs,
+    resolvers
+  });
+  const schema = await graphQLLoadSchemaSync(silgi.options.serverDir, {
+    cwd: silgi.options.rootDir
+  });
+  const makeSchema = makeExecutableSchema({
+    typeDefs,
+    resolvers
+  });
+  const merge = mergeSchemas({
+    schemas: schema ? [makeSchema, schema] : [makeSchema]
+  });
+  if (merge) {
+    const schemaString = printSchemaWithDirectives(merge);
+    const context = [
+      "// THIS FILE IS GENERATED, DO NOT EDIT!",
+      "/* eslint-disable eslint-comments/no-unlimited-disable */",
+      "/* tslint:disable */",
+      "/* eslint-disable */",
+      "/* prettier-ignore */",
+      "/* silgi */",
+      "export const schema = `",
+      "",
+      schemaString,
+      "",
+      "`"
+    ].join("\n");
+    const fsPath = join$1(silgi.options.silgi.serverDir, "generated/graphql.schema.ts");
+    await promises.mkdir(dirname(fsPath), { recursive: true });
+    await promises.writeFile(fsPath, context);
+  }
+  return {
+    schema
+  };
+}
+
+function moduleScanHooks(silgi) {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    for (const module of silgi.scanModules) {
+      const exports = module.meta.exports;
+      if (exports?.interface) {
+        let importName;
+        options.importItems[module.meta.configKey] = {
+          import: [],
+          from: module.meta._packageName
+        };
+        if (exports.interface.config) {
+          importName = pascalCase(`${module.meta.configKey}Config`);
+          options.importItems[module.meta.configKey].import.push({
+            name: `SilgiModuleOptions as ${importName}`,
+            type: true
+          });
+          options.configs.push({
+            key: module.meta.configKey,
+            value: importName
+          });
+        }
+        if (exports.interface.context) {
+          importName = pascalCase(`${module.meta.configKey}Context`);
+          options.importItems[module.meta.configKey].import.push({
+            name: `SilgiModuleContext as ${importName}`,
+            type: true
+          });
+          options.contexts.push({
+            key: module.meta.configKey,
+            value: importName
+          });
+        }
+        if (exports.interface.method) {
+          importName = pascalCase(`${module.meta.configKey}Method`);
+          options.importItems[module.meta.configKey].import.push({
+            name: `SilgiModuleMethods as ${importName}`,
+            type: true
+          });
+          options.methods.push({
+            key: module.meta.configKey,
+            value: importName
+          });
+        }
+        if (exports.interface.shared) {
+          importName = pascalCase(`${module.meta.configKey}Shared`);
+          options.importItems[module.meta.configKey].import.push({
+            name: `SilgiModuleShared as ${importName}`,
+            type: true
+          });
+          options.shareds.push({
+            key: module.meta.configKey,
+            value: importName
+          });
+        }
+      }
+    }
+  });
+}
+
+async function afterModuleScan(silgi) {
+  await moduleScanHooks(silgi);
+}
+
+async function loadSilgiModuleInstance(silgiModule) {
+  if (typeof silgiModule === "string") {
+    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+  }
+  if (typeof silgiModule !== "function") {
+    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
+  }
+  return { silgiModule };
+}
+async function installModules(silgi) {
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias
+  });
+  for (const module of silgi.scanModules) {
+    if (hasInstalledModule(module.meta.configKey)) {
+      silgi.logger.info(`Module ${module.meta.configKey} installed`);
+    }
+    try {
+      const silgiModule = await jiti.import(module.entryPath, {
+        default: true,
+        conditions: silgi.options.conditions
+      });
+      await installModule(silgiModule, silgi);
+    } catch (err) {
+      silgi.logger.error(err);
+    }
+  }
+}
+async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions) {
+  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
+  const res = await silgiModule({}, silgi) ?? {};
+  if (res === false) {
+    return false;
+  }
+  const metaData = await silgiModule.getMeta?.();
+  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
+  if (installedModule) {
+    installedModule.installed = true;
+  } else {
+    throw new Error(`Module ${metaData?.name} not found`);
+  }
+}
+
+const logger = consola;
+async function _resolveSilgiModule(mod, silgi) {
+  let _url;
+  let buildTimeModuleMeta = {};
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias
+  });
+  if (typeof mod === "string") {
+    const paths = /* @__PURE__ */ new Set();
+    mod = resolveAlias$1(mod, silgi.options.alias);
+    if (isRelative(mod)) {
+      mod = resolve(silgi.options.rootDir, mod);
+    }
+    paths.add(join(mod, "silgi"));
+    paths.add(join(mod, "module"));
+    paths.add(mod);
+    for (const path of paths) {
+      try {
+        const src = isAbsolute(path) ? pathToFileURL(await resolvePath$1(path, { fallbackToOriginal: false, extensions: silgi.options.extensions })).href : await resolve$1(path, { url: silgi.options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: silgi.options.extensions });
+        mod = await jiti.import(src, {
+          default: true,
+          conditions: silgi.options.conditions
+        });
+        _url = fileURLToPath(new URL(src));
+        const moduleMetadataPath = new URL("module.json", src);
+        if (existsSync(moduleMetadataPath)) {
+          buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+        } else {
+          if (typeof mod === "function") {
+            const meta = await mod.getMeta?.();
+            buildTimeModuleMeta = {
+              ...meta
+            };
+          }
+        }
+        break;
+      } catch (error) {
+        const code = error.code;
+        if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
+          continue;
+        }
+        logger.error(`Error while importing module \`${mod}\`: ${error}`);
+        throw error;
+      }
+    }
+  }
+  if (!buildTimeModuleMeta) {
+    throw new Error(`Module ${mod} is not a valid Silgi module`);
+  }
+  if (typeof mod === "function") {
+    silgi.scanModules.push({
+      meta: buildTimeModuleMeta,
+      entryPath: _url,
+      installed: false
+    });
+  }
+}
+async function scanModules$1(silgi) {
+  const _modules = [
+    ...silgi.options._modules,
+    ...silgi.options.modules
+  ];
+  for await (const mod of _modules) {
+    await _resolveSilgiModule(mod, silgi);
+  }
+  const moduleMap = new Map(
+    silgi.scanModules.map((m) => [m.meta?.configKey, m])
+  );
+  const graph = createDependencyGraph(silgi.scanModules);
+  const sortedKeys = topologicalSort(graph);
+  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
+  silgi.scanModules = modules;
+}
+function createDependencyGraph(modules) {
+  const graph = /* @__PURE__ */ new Map();
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    if (key) {
+      graph.set(key, /* @__PURE__ */ new Set());
+    }
+  });
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    const deps = module.meta?.dependencies || [];
+    if (key && deps.length > 0) {
+      const modulesDeps = graph.get(key) || /* @__PURE__ */ new Set();
+      deps.forEach((dep) => {
+        if (graph.has(dep)) {
+          modulesDeps.add(dep);
+        }
+      });
+      graph.set(key, modulesDeps);
+    }
+  });
+  return graph;
+}
+function topologicalSort(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const temp = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(node) {
+    if (temp.has(node)) {
+      throw new Error(`D\xF6ng\xFCsel ba\u011F\u0131ml\u0131l\u0131k tespit edildi: ${node}`);
+    }
+    if (visited.has(node))
+      return;
+    temp.add(node);
+    const deps = graph.get(node) || /* @__PURE__ */ new Set();
+    for (const dep of deps) {
+      visit(dep);
+    }
+    temp.delete(node);
+    visited.add(node);
+    order.push(node);
+  }
+  for (const [node, deps] of graph.entries()) {
+    if (deps.size === 0 && !visited.has(node)) {
+      visit(node);
+    }
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) {
+      visit(node);
+    }
+  }
+  return order;
+}
+
+function resolveIgnorePatterns(silgi, relativePath) {
+  if (!silgi) {
+    return [];
+  }
+  const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
+  const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
+  if (existsSync(nuxtignoreFile)) {
+    const contents = readFileSync(nuxtignoreFile, "utf-8");
+    ignorePatterns.push(...contents.trim().split(/\r?\n/));
+  }
+  return ignorePatterns;
+}
+function isIgnored(pathname, silgi, _stats) {
+  if (!silgi) {
+    return false;
+  }
+  if (!silgi._ignore) {
+    silgi._ignore = ignore(silgi.options.ignoreOptions);
+    silgi._ignore.add(resolveIgnorePatterns(silgi));
+  }
+  const relativePath = relative(silgi.options.rootDir, pathname);
+  if (relativePath[0] === "." && relativePath[1] === ".") {
+    return false;
+  }
+  return !!(relativePath && silgi._ignore.ignores(relativePath));
+}
+function resolveGroupSyntax(group) {
+  let groups = [group];
+  while (groups.some((group2) => group2.includes("{"))) {
+    groups = groups.flatMap((group2) => {
+      const [head, ...tail] = group2.split("{");
+      if (tail.length) {
+        const [body = "", ...rest] = tail.join("{").split("}");
+        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
+      }
+      return group2;
+    });
+  }
+  return groups;
+}
+
+async function scanFiles$1(silgi) {
+  const filePaths = /* @__PURE__ */ new Set();
+  const scannedPaths = [];
+  const dir = silgi.options.serverDir;
+  const files = (await globby(dir, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
+  if (files.length) {
+    const siblings = await readdir(dirname(dir)).catch(() => []);
+    const directory = basename(dir);
+    if (!siblings.includes(directory)) {
+      const directoryLowerCase = directory.toLowerCase();
+      const caseCorrected = siblings.find((sibling) => sibling.toLowerCase() === directoryLowerCase);
+      if (caseCorrected) {
+        const original = relative(silgi.options.serverDir, dir);
+        const corrected = relative(silgi.options.serverDir, join(dirname(dir), caseCorrected));
+        consola.warn(`Components not scanned from \`~/${corrected}\`. Did you mean to name the directory \`~/${original}\` instead?`);
+      }
+    }
+  }
+  for (const _file of files) {
+    const filePath = resolve(dir, _file);
+    if (scannedPaths.find((d) => filePath.startsWith(withTrailingSlash(d))) || isIgnored(filePath, silgi)) {
+      continue;
+    }
+    if (filePaths.has(filePath)) {
+      continue;
+    }
+    filePaths.add(filePath);
+    if (silgi.options.extensions.includes(extname(filePath))) {
+      const parser = new SchemaParser({
+        debug: false
+      });
+      const readfile = readFileSync(filePath, "utf-8");
+      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
+      const createServices = exportVariables("createService", filePath);
+      if (createServices.length > 0) {
+        for (const createService of createServices) {
+          const { exportName, path } = createService;
+          silgi.hook("prepare:core.ts", (options) => {
+            options.services.push(exportName);
+          });
+          silgi.hook("prepare:core.ts", (options) => {
+            options.importItems[path] ??= {
+              import: [],
+              from: relativeWithDot(silgi.options.silgi.serverDir, path)
+            };
+            options.importItems[path].import.push({
+              name: exportName
+            });
+          });
+        }
+      }
+      const createSchemas = exportVariables("createSchema", filePath);
+      if (createSchemas.length > 0) {
+        for (const createSchema of createSchemas) {
+          const { exportName, path } = createSchema;
+          silgi.hook("prepare:core.ts", (options) => {
+            options.schemas.push(exportName);
+          });
+          silgi.hook("prepare:core.ts", (options) => {
+            options.importItems[path] ??= {
+              import: [],
+              from: relativeWithDot(silgi.options.silgi.serverDir, path)
+            };
+            options.importItems[path].import.push({
+              name: exportName
+            });
+          });
+        }
+      }
+      const createShareds = exportVariables("createShared", filePath);
+      if (createShareds.length > 0) {
+        for (const createShared of createShareds) {
+          const { exportName, path } = createShared;
+          silgi.hook("prepare:core.ts", (options) => {
+            options.shareds.push(exportName);
+          });
+          silgi.hook("prepare:core.ts", (options) => {
+            options.importItems[path] ??= {
+              import: [],
+              // Relative path kaldirmamiz gerekiyor bunlar hooklarin bittigi yerde karar verilmeli.
+              from: relativeWithDot(silgi.options.silgi.serverDir, path)
+            };
+            options.importItems[path].import.push({
+              name: exportName
+            });
+          });
+        }
+      }
+      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
+      if (sharedsTypes.length > 0) {
+        for (const sharedType of sharedsTypes) {
+          const { exportName, path } = sharedType;
+          silgi.hook("prepare:schema.ts", (options) => {
+            options.shareds.push({
+              key: exportName,
+              value: exportName
+            });
+          });
+          silgi.hook("prepare:schema.ts", (options) => {
+            options.importItems[path] ??= {
+              import: [],
+              from: path
+            };
+            options.importItems[path].import.push({
+              name: exportName,
+              type: true
+            });
+          });
+        }
+      }
+      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
+      if (contextTypes.length > 0) {
+        for (const contextType of contextTypes) {
+          const { exportName, path } = contextType;
+          silgi.hook("prepare:schema.ts", (options) => {
+            options.contexts.push({
+              key: exportName,
+              value: exportName
+            });
+          });
+          silgi.hook("prepare:schema.ts", (options) => {
+            options.importItems[path] ??= {
+              import: [],
+              from: path
+            };
+            options.importItems[path].import.push({
+              name: exportName,
+              type: true
+            });
+          });
+        }
+      }
+    }
+  }
+}
+
+async function createStorageCLI(silgi) {
+  const storage = createStorage();
+  const mounts = klona({
+    ...silgi.options.storage,
+    ...silgi.options.devStorage
+  });
+  for (const [path, opts] of Object.entries(mounts)) {
+    if (opts.driver) {
+      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+      storage.mount(path, driver(opts));
+    } else {
+      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+    }
+  }
+  return storage;
+}
+
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+async function scanAndSyncOptions(silgi) {
+  const scannedModules = await scanModules(silgi);
+  silgi.options.modules = silgi.options.modules || [];
+  for (const modPath of scannedModules) {
+    if (!silgi.options.modules.includes(modPath)) {
+      silgi.options.modules.push(modPath);
+    }
+  }
+}
+async function scanModules(silgi) {
+  const files = await scanFiles(silgi, "modules");
+  return files.map((f) => f.fullPath);
+}
+async function scanFiles(silgi, name) {
+  const files = await Promise.all(
+    silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))
+  ).then((r) => r.flat());
+  return files;
+}
+async function scanDir(silgi, dir, name) {
+  const fileNames = await globby(join(name, GLOB_SCAN_PATTERN), {
+    cwd: dir,
+    dot: true,
+    ignore: silgi.options.ignore,
+    absolute: true
+  });
+  return fileNames.map((fullPath) => {
+    return {
+      fullPath,
+      path: relative(join(dir, name), fullPath)
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+async function createSilgiCLI(config = {}, opts = {}) {
+  const options = await loadOptions(config, opts);
+  const hooks = createHooks();
+  const silgi = {
+    modulesURIs: {},
+    scannedURIs: /* @__PURE__ */ new Map(),
+    services: {},
+    uris: {},
+    shareds: {},
+    schemas: {},
+    unimport: undefined,
+    options,
+    hooks,
+    // vfs: {}
+    _requiredModules: {},
+    logger: consola.withTag("silgi"),
+    close: () => silgi.hooks.callHook("close", silgi),
+    storage: undefined,
+    scanModules: [],
+    _modules: [],
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    async updateConfig(_config) {
+    }
+  };
+  if (silgiCLICtx.tryUse()) {
+    silgiCLICtx.unset();
+    silgiCLICtx.set(silgi);
+  } else {
+    silgiCLICtx.set(silgi);
+    silgi.hook("close", () => silgiCLICtx.unset());
+  }
+  if (silgi.options.debug) {
+    createDebugger(silgi.hooks, { tag: "silgi" });
+    silgi.options.plugins.push({
+      path: join(runtimeDir, "internal/debug"),
+      packageImport: "silgi/runtime/internal/debug"
+    });
+  }
+  await scanAndSyncOptions(silgi);
+  await scanModules$1(silgi);
+  await scanFiles$1(silgi);
+  await graphqlLoadSync(silgi);
+  silgi.storage = await createStorageCLI(silgi);
+  silgi.hooks.hook("close", async () => {
+    await silgi.storage.dispose();
+  });
+  if (silgi.options.logLevel !== undefined) {
+    silgi.logger.level = silgi.options.logLevel;
+  }
+  await installModules(silgi);
+  if (silgi.options.imports) {
+    silgi.unimport = createUnimport(silgi.options.imports);
+    await silgi.unimport.init();
+  }
+  await afterModuleScan(silgi);
+  return silgi;
+}
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const silgi = await createSilgiCLI({ rootDir });
+    await prepare$1(silgi);
+    for (const framework of frameworkSetup) {
+      await framework(silgi);
+    }
+    await writeTypesAndFiles(silgi);
+    await scanUris(silgi);
+    await silgi.callHook("read:core.ts", async () => {
+      const data = await readCoreFile(silgi);
+      return data;
+    });
+    await silgi.close();
+  }
+});
+
+export { prepare as default };