silgi 0.3.13 → 0.4.1

package/dist/chunks/generate.mjs

@@ -1,1257 +0,0 @@
-import { defineCommand } from 'citty';
-import { r as relativeWithDot, k as getDirectory, m as resolveSilgiModule, o as resolvePath$1, q as generateUris, v as generateSilgiStorageBaseType, l as loadSilgiConfig } from '../shared/silgi.D2yb1XAa.mjs';
-import { createHooks } from 'hookable';
-import ignore from 'ignore';
-import { isAbsolute, resolve, join, relative, dirname, basename, extname } from 'pathe';
-import { promises, existsSync, writeFileSync, readFileSync } from 'node:fs';
-import { readPackageJSON } from 'pkg-types';
-import { defu } from 'defu';
-import { withTrailingSlash } from 'ufo';
-import { resolvePath, resolve as resolve$1 } from 'mlly';
-import { readdir } from 'node:fs/promises';
-import { consola } from 'consola';
-import { globby } from 'globby';
-import { parseSync } from '@oxc-parser/wasm';
-import { createJiti } from 'jiti';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { pascalCase } from 'scule';
-import 'node:buffer';
-import 'klona';
-import 'unstorage';
-import 'unstorage/drivers/memory';
-import 'unctx';
-import 'c12';
-import 'untyped';
-import 'std-env';
-import 'pathe/utils';
-
-async function _generateH3DTS(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importedItems = {
-    silgi: {
-      import: [
-        { name: "URIsTypes", type: true },
-        { name: "Namespaces", type: true },
-        { name: "SilgiModuleContext", type: true }
-      ],
-      from: "silgi"
-    }
-  };
-  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 (importedItems[pkg.name]) {
-      importedItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  const imports = [];
-  await silgi.callHook("prepare:h3.d.ts", {
-    importedItems,
-    imports
-  });
-  const importData = [
-    "// Generated by silgi",
-    ...Object.entries(importedItems).map(([_name, { from, import: imports2 }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.buildDir, from) : from;
-      return `import { ${imports2.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...imports,
-    "",
-    'declare module "h3" {',
-    "  interface H3EventContext extends SilgiModuleContext {}",
-    "}",
-    ""
-  ].join("\n");
-  return {
-    importData
-  };
-}
-async function writeH3DTS(silgi) {
-  if (silgi.options.environment !== "h3")
-    return;
-  silgi.hook("prepare:schema.ts", (options) => {
-    options.importedItems.h3 ??= {
-      import: [
-        { name: "H3Event", type: true }
-      ],
-      from: "h3"
-    };
-    options.events.push({
-      key: "H3Event",
-      value: "H3Event",
-      extends: true,
-      isSilgiContext: false
-    });
-  });
-  const { importData } = await _generateH3DTS(silgi);
-  async function writeFile() {
-    const GeneratedBy = "// Generated by silgi";
-    const tsConfigPath = resolve(silgi.options.buildDir, "h3.d.ts");
-    await promises.mkdir(silgi.options.buildDir, { recursive: true });
-    await promises.writeFile(tsConfigPath, `${GeneratedBy}
-${importData}`);
-  }
-  await writeFile();
-}
-
-async function _generateSchemaFile(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importedItems = {
-    silgi: {
-      import: [
-        { name: "URIsTypes", type: true },
-        { name: "Namespaces", type: true },
-        { name: "SilgiModuleContext", type: true }
-      ],
-      from: "silgi"
-    }
-  };
-  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 (importedItems[pkg.name]) {
-      importedItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  const imports = [];
-  const configs = [];
-  const contexts = [];
-  const methods = [];
-  const shareds = [];
-  const events = [];
-  const storeBase = [];
-  await silgi.callHook("prepare:schema.ts", {
-    importedItems,
-    imports,
-    configs,
-    contexts,
-    methods,
-    shareds,
-    storeBase,
-    events
-  });
-  const silgiExport = relativeWithDot(silgi.options.buildDir, `${silgi.options.silgiDir}/core.ts`);
-  let addSilgiContext = false;
-  const importData = [
-    ...Object.entries(importedItems).map(([_name, { from, import: imports2 }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.buildDir, from) : from;
-      return `import { ${imports2.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...imports,
-    "",
-    "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' {",
-    " interface SilgiSchema extends SchemaExtends {}",
-    "",
-    " interface SilgiValidationSchema {",
-    `  validationLibrary: '${silgi.options.validationLibrary}'`,
-    " }",
-    "",
-    " interface SilgiNamespaces extends InferredNamespaces {}",
-    "",
-    " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
-    "",
-    " interface SilgiModules extends SilgiModuleOptionsExtends {}",
-    "",
-    " interface SilgiURIs extends SilgiURIsMerge {}",
-    "",
-    " interface SilgiConfig extends Partial<SilgiModuleOptionsExtends> {}",
-    "",
-    " interface SilgiModuleContext extends SilgiModuleContextExtends {}",
-    "",
-    " interface SilgiEvent extends SilgiModuleEventsExtends {}",
-    "",
-    " interface SilgiDefaultShared extends SilgiModuleSharedExtends {}",
-    "",
-    " interface SilgiModuleMethods extends SilgiModuleMethodsExtends {}",
-    "",
-    " interface SilgiModuleOptions extends SilgiModuleOptionsExtends {}",
-    "}",
-    "",
-    "export {}"
-  ].join("\n");
-  return {
-    importData,
-    importedItems
-  };
-}
-async function writeSchema(silgi) {
-  const { importData } = await _generateSchemaFile(silgi);
-  async function writeFile() {
-    const GeneratedBy = "// Generated by silgi";
-    const tsConfigPath = resolve(silgi.options.buildDir, "schema.d.ts");
-    await promises.mkdir(silgi.options.buildDir, { recursive: true });
-    await promises.writeFile(tsConfigPath, `${GeneratedBy}
-${importData}`);
-  }
-  await writeFile();
-}
-
-async function _generateSilgiFile(silgi) {
-  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
-  const importedItems = {
-    silgi: {
-      import: [
-        { name: "createSilgi" },
-        { name: "SilgiModuleOptions", type: true },
-        { name: "SilgiOptions", type: true }
-      ],
-      from: "silgi"
-    }
-  };
-  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 (importedItems[pkg.name]) {
-      importedItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
-    }
-  }));
-  const imports = [];
-  const uris = [];
-  const services = [];
-  const shareds = [];
-  const schemas = [];
-  const modules = [];
-  await silgi.callHook("prepare:core.ts", {
-    importedItems,
-    imports,
-    uris,
-    services,
-    shareds,
-    schemas,
-    modules
-  });
-  if (services.length > 0) {
-    importedItems.silgi.import.push({ name: "mergeServices" });
-  }
-  if (shareds.length > 0) {
-    importedItems.silgi.import.push({ name: "mergeShared" });
-  }
-  if (schemas.length > 0) {
-    importedItems.silgi.import.push({ name: "mergeSchemas" });
-  }
-  const importData = [
-    ...Object.entries(importedItems).map(([_name, { from, import: imports2 }]) => {
-      return `import { ${imports2.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
-    }),
-    ...imports,
-    "",
-    "export const uris = {}",
-    "",
-    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(options?: Partial<SilgiModuleOptions>) {",
-    "  const silgi = await createSilgi({",
-    "      shared: shareds as any,",
-    "      services: services as any,",
-    "      schemas: schemas as any,",
-    "      uris,",
-    "      _initializedModules: {",
-    ...modules.map((name) => {
-      return `        ${name},`;
-    }),
-    "      } as any,",
-    "",
-    "      options: {",
-    "      ...silgiOptions,",
-    "      ...options,",
-    "     },",
-    "    })",
-    "",
-    "  return silgi",
-    "}",
-    ""
-  ].join("\n");
-  return {
-    importData,
-    importedItems
-  };
-}
-async function writeSilgiFile(silgi) {
-  const { importData } = await _generateSilgiFile(silgi);
-  async function writeFile() {
-    const GeneratedBy = "// Generated by silgi";
-    const copySilgi = JSON.parse(JSON.stringify(silgi.options));
-    delete copySilgi.modulesDir;
-    delete copySilgi.buildDir;
-    delete copySilgi.silgiDir;
-    delete copySilgi.serverDir;
-    delete copySilgi.rootDir;
-    delete copySilgi.tsconfig;
-    delete copySilgi.dir;
-    delete copySilgi.ignore;
-    delete copySilgi.hooks;
-    delete copySilgi.alias;
-    delete copySilgi.extensions;
-    delete copySilgi.typescript;
-    delete copySilgi.typeCheck;
-    delete copySilgi.tsConfig;
-    delete copySilgi._silgiConfigFile;
-    delete copySilgi._silgiConfigFiles;
-    delete copySilgi._requiredModules;
-    delete copySilgi._modules;
-    copySilgi._installedModules?.map((m) => {
-      m.entryPath = "";
-      m.active = false;
-      m.packageName = "";
-      return m;
-    });
-    const silgiObject = JSON.stringify(copySilgi, null, 2);
-    const newImportData = importData.replace("silgiOptions: Partial<SilgiOptions> = {}", `silgiOptions: Partial<SilgiOptions> = ${silgiObject}`);
-    const tsConfigPath = resolve(silgi.options.silgiDir, "core.ts");
-    await promises.mkdir(silgi.options.silgiDir, { recursive: true });
-    await promises.writeFile(tsConfigPath, `${GeneratedBy}
-${newImportData}`);
-  }
-  await writeFile();
-}
-
-async function tryResolveModule(id, url = import.meta.url) {
-  try {
-    return await resolvePath(id, { url });
-  } catch {
-  }
-}
-
-function renderAttrs(obj) {
-  const attrs = [];
-  for (const key in obj) {
-    attrs.push(renderAttr(key, obj[key]));
-  }
-  return attrs.join(" ");
-}
-function renderAttr(key, value) {
-  return value ? `${key}="${value}"` : "";
-}
-const EXTENSION_RE = /\b\.\w+$/g;
-const excludedAlias = [/^@vue\/.*$/, /^#internal\/nuxt/];
-async function _generateTypes(silgi) {
-  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
-  const relativeRootDir = relativeWithDot(silgi.options.buildDir, silgi.options.rootDir);
-  const include = /* @__PURE__ */ new Set([
-    "./silgi.d.ts",
-    "./schema.d.ts",
-    join(relativeRootDir, ".config/silgi.*"),
-    join(relativeRootDir, "**/*")
-  ]);
-  const exclude = /* @__PURE__ */ new Set([
-    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
-    relativeWithDot(silgi.options.buildDir, resolve(silgi.options.rootDir, "dist"))
-  ]);
-  for (const dir of silgi.options.modulesDir) {
-    exclude.add(relativeWithDot(silgi.options.buildDir, dir));
-  }
-  const moduleEntryPaths = [];
-  for (const m of silgi.options._installedModules) {
-    if (m.entryPath) {
-      moduleEntryPaths.push(getDirectory(m.entryPath));
-    }
-  }
-  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
-  for (const path of modulePaths) {
-    const relative2 = relativeWithDot(silgi.options.buildDir, path);
-    include.add(join(relative2, "runtime"));
-    exclude.add(join(relative2, "runtime/server"));
-    include.add(join(relative2, "dist/runtime"));
-    exclude.add(join(relative2, "dist/runtime/server"));
-  }
-  const tsConfig = defu(silgi.options.typescript?.tsConfig, {
-    compilerOptions: {
-      forceConsistentCasingInFileNames: true,
-      strict: silgi.options.typescript.strict,
-      noEmit: true,
-      target: "ESNext",
-      module: "ESNext",
-      moduleResolution: "Bundler",
-      allowJs: true,
-      resolveJsonModule: true,
-      jsx: "preserve",
-      allowSyntheticDefaultImports: true,
-      jsxFactory: "h",
-      jsxFragmentFactory: "Fragment",
-      allowImportingTsExtensions: true
-    },
-    include: [...include],
-    exclude: [...exclude]
-  });
-  const aliases = silgi.options.alias;
-  const basePath = tsConfig.compilerOptions.baseUrl ? resolve(silgi.options.buildDir, tsConfig.compilerOptions.baseUrl) : silgi.options.buildDir;
-  tsConfig.compilerOptions ||= {};
-  tsConfig.compilerOptions.paths ||= {};
-  tsConfig.include ||= [];
-  for (const alias in aliases) {
-    if (excludedAlias.some((re) => re.test(alias))) {
-      continue;
-    }
-    let absolutePath = resolve(basePath, aliases[alias]);
-    let stats = await promises.stat(absolutePath).catch(
-      () => null
-      /* file does not exist */
-    );
-    if (!stats) {
-      const resolvedModule = await tryResolveModule(aliases[alias], silgi.options.modulesDir);
-      if (resolvedModule) {
-        absolutePath = resolvedModule;
-        stats = await promises.stat(resolvedModule).catch(() => null);
-      }
-    }
-    const relativePath = relativeWithDot(silgi.options.buildDir, absolutePath);
-    if (stats?.isDirectory()) {
-      tsConfig.compilerOptions.paths[alias] = [relativePath];
-      tsConfig.compilerOptions.paths[`${alias}/*`] = [`${relativePath}/*`];
-      if (!absolutePath.startsWith(rootDirWithSlash)) {
-        tsConfig.include.push(relativePath);
-      }
-    } else {
-      const path = stats?.isFile() ? relativePath.replace(EXTENSION_RE, "") : aliases[alias];
-      tsConfig.compilerOptions.paths[alias] = [path];
-      if (!absolutePath.startsWith(rootDirWithSlash)) {
-        tsConfig.include.push(path);
-      }
-    }
-  }
-  const references = [];
-  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);
-    references.push({ types: pkg?.name || id });
-  }));
-  const declarations = [];
-  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
-  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.buildDir, p) : p))];
-  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.buildDir, p) : p))];
-  const declaration = [
-    ...references.map((ref) => {
-      if ("path" in ref && isAbsolute(ref.path)) {
-        ref.path = relative(silgi.options.buildDir, ref.path);
-      }
-      return `/// <reference ${renderAttrs(ref)} />`;
-    }),
-    ...declarations,
-    "",
-    "export {}",
-    ""
-  ].join("\n");
-  return {
-    declaration,
-    tsConfig
-  };
-}
-async function writeTsConfig(silgi) {
-  const { tsConfig, declaration } = await _generateTypes(silgi);
-  async function writeFile() {
-    const GeneratedBy = "// Generated by silgi";
-    const tsConfigPath = resolve(silgi.options.buildDir, "tsconfig.json");
-    await promises.mkdir(silgi.options.buildDir, { recursive: true });
-    await promises.writeFile(tsConfigPath, `${GeneratedBy}
-${JSON.stringify(tsConfig, null, 2)}`);
-    const declarationPath = resolve(silgi.options.buildDir, "silgi.d.ts");
-    await promises.writeFile(declarationPath, `${GeneratedBy}
-${declaration}`);
-  }
-  await writeFile();
-}
-async function tsconfigExists(silgi) {
-  const tsConfigPath = resolve(silgi.options.rootDir, "tsconfig.json");
-  return existsSync(tsConfigPath);
-}
-async function writeRootTsConfig(silgi) {
-  if (await tsconfigExists(silgi)) {
-    return;
-  }
-  const GeneratedBy = `// Generated by silgi'
-{
-  "references": [
-    {
-      "path": "./.silgi/tsconfig.json"
-    },
-    {
-      "path": "./.silgi/tsconfig.client.json"
-    }
-  ],
-  "files": []
-}
-  `;
-  const tsConfigPath = resolve(silgi.options.rootDir, "tsconfig.json");
-  await promises.mkdir(silgi.options.rootDir, { recursive: true });
-  await promises.writeFile(tsConfigPath, GeneratedBy);
-}
-
-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'",
-        "",
-        "export interface RouterTypes {",
-        routerTypes.join(",\n"),
-        "}",
-        "",
-        "declare module 'silgi' {",
-        "  interface SilgiRouterTypes extends RouterTypes {",
-        "  }",
-        "}",
-        "",
-        silgi.options.environment === "h3" || silgi.options.environment === "nitrojs" ? nitro.join("\n") : "",
-        "",
-        "export {}"
-      ].join("\n");
-      const outputPath = resolve(silgi.options.buildDir, "silgi-routes.d.ts");
-      await promises.writeFile(outputPath, context);
-    });
-  });
-}
-
-async function writeTypes(silgi) {
-  await writeH3DTS(silgi);
-  await generateRouterDTS(silgi);
-  await writeSilgiFile(silgi);
-  await writeSchema(silgi);
-  await writeTsConfig(silgi);
-  await writeRootTsConfig(silgi);
-}
-
-class SchemaParser {
-  options = {
-    debug: false
-  };
-  /**
-   *
-   */
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  parseExports(content, filePath) {
-    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
-    if (this.options.debug)
-      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
-    return {
-      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
-      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
-      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
-    };
-  }
-  parseVariableDeclaration(ast) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
-  }
-  parseTSInterfaceDeclaration(ast) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
-  }
-  parseTypeDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseVariableDeclaration(ast)) {
-      for (const declaration of item.declaration.declarations) {
-        if (declaration.init.callee?.name === find) {
-          const options = {};
-          if (declaration.init.arguments) {
-            for (const argument of declaration.init.arguments) {
-              for (const propertie of argument.properties) {
-                if (propertie.key.name === "name")
-                  options.pluginName = propertie.value.value;
-              }
-            }
-          }
-          for (const key in declaration.init.properties) {
-            const property = declaration.init.properties[key];
-            if (property.type === "ObjectProperty") {
-              if (property.key.name === "options") {
-                for (const key2 in property.value.properties) {
-                  const option = property.value.properties[key2];
-                  if (option.type === "ObjectProperty") {
-                    options[option.key.name] = option.value.value;
-                  }
-                }
-              }
-            }
-          }
-          options.type = false;
-          data.push({
-            exportName: declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  parseInterfaceDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseTSInterfaceDeclaration(ast)) {
-      if (!item?.declaration?.extends)
-        continue;
-      for (const declaration of item?.declaration?.extends) {
-        if (declaration.expression.name === find) {
-          const options = {};
-          options.type = true;
-          data.push({
-            exportName: item.declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  // private parsePlugin(ast: any, path: string = '') {
-  //   const data = {
-  //     export: [],
-  //     name: '',
-  //     path: '',
-  //   } as DataTypePlugin
-  //   for (const item of this.parseVariableDeclaration(ast)) {
-  //     for (const declaration of item.declaration.declarations) {
-  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
-  //         if (declaration.init.arguments) {
-  //           for (const argument of declaration.init.arguments) {
-  //             for (const propertie of argument.properties) {
-  //               if (propertie.key.name === 'name')
-  //                 data.name = propertie.value.value
-  //             }
-  //           }
-  //         }
-  //         data.export.push({
-  //           name: data.name,
-  //           as: camelCase(`${data.name}DefineSilgiModule`),
-  //           type: false,
-  //         })
-  //       }
-  //     }
-  //   }
-  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
-  //     if (!item?.declaration?.extends)
-  //       continue
-  //     for (const declaration of item?.declaration?.extends) {
-  //       if (declaration.expression.name === 'SilgiModuleOptions') {
-  //         data.export.push({
-  //           name: item.declaration.id.name,
-  //           as: camelCase(`${data.name}SilgiModuleOptions`),
-  //           type: true,
-  //         })
-  //       }
-  //       // TODO add other plugins
-  //     }
-  //   }
-  //   data.path = path
-  //   console.log(data)
-  //   return data
-  // }
-}
-
-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(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.importedItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgiDir, path)
-            };
-            options.importedItems[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.importedItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgiDir, path)
-            };
-            options.importedItems[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.importedItems[path] ??= {
-              import: [],
-              // Relative path kaldirmamiz gerekiyor bunlar hooklarin bittigi yerde karar verilmeli.
-              from: relativeWithDot(silgi.options.silgiDir, path)
-            };
-            options.importedItems[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.importedItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importedItems[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.importedItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importedItems[path].import.push({
-              name: exportName,
-              type: true
-            });
-          });
-        }
-      }
-    }
-  }
-}
-
-async function readSilgiTs(silgi) {
-  const path = resolve(silgi.options.silgiDir, "core.ts");
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: false,
-    interopDefault: true,
-    moduleCache: false
-  });
-  const context = await promises.readFile(path, "utf-8");
-  const coreFile = await jiti.import(
-    path
-  );
-  return {
-    context,
-    object: {
-      schemas: coreFile.schemas,
-      uris: coreFile.uris,
-      services: coreFile.services,
-      shareds: coreFile.shareds
-    },
-    path
-  };
-}
-
-const logger = consola;
-async function loadCLISilgiModuleInstance(silgiModule, silgi) {
-  const buildTimeModuleMeta = {};
-  let resolvedModulePath;
-  const resolvedModulePaths = [];
-  const jiti = createJiti(silgi.options.rootDir);
-  if (typeof silgiModule === "string") {
-    const paths = /* @__PURE__ */ new Set();
-    if (!/\.(?:js|ts|mjs)$/.test(silgiModule))
-      paths.add(`${silgiModule}/module`);
-    paths.add(silgiModule);
-    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 });
-        silgiModule = await jiti.import(src, { default: true });
-        resolvedModulePath = fileURLToPath(new URL(src));
-      } 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 \`${silgiModule}\`: ${error}`);
-        throw error;
-      }
-    }
-  }
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function" && !silgi.options.isPackage) {
-    if (typeof silgiModule === "object" && silgiModule.name === "modules") {
-      for (const item of silgiModule.modules) {
-        const path = resolvedModulePath?.replace(/\/module\.(mjs|ts)$/, `/${item}/module.$1`);
-        if (path) {
-          resolvedModulePaths?.push({
-            name: item,
-            path,
-            multiple: true
-          });
-        }
-      }
-    } else {
-      throw new TypeError(`Silgi module should be a function: ${silgiModule}`);
-    }
-  }
-  if (typeof silgiModule === "function") {
-    const meta = await silgiModule.getMeta?.();
-    resolvedModulePaths?.push({
-      name: meta.configKey || meta.name,
-      path: resolvedModulePath
-    });
-  }
-  for (const module of resolvedModulePaths) {
-    const silgiModule2 = await jiti.import(module.path, { default: true });
-    await silgiModule2({}, silgi, true);
-  }
-  return { silgiModule, buildTimeModuleMeta, resolvedModulePath, resolvedModulePaths };
-}
-async function loadCLISilgiModule(jiti, item, module, silgi, packageName) {
-  const moduleResolved = await jiti.import(item.path, { default: true });
-  if (typeof moduleResolved === "string") {
-    throw new TypeError(`Could not load \`${item.name}\`. Is it installed?`);
-  }
-  if (typeof moduleResolved !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${item.name}`);
-  }
-  const meta = await moduleResolved?.getMeta?.();
-  if (!meta) {
-    throw new TypeError(`Could not load \`${item.name}\`.`);
-  }
-  silgi.hook("prepare:core.ts", async (options) => {
-    if (packageName) {
-      if (item.multiple) {
-        options.imports.push(`import ${item.name} from '${packageName}/${item.name}'`);
-        silgi.options._installedModules.push({
-          meta,
-          entryPath: item.path,
-          packageName: `${packageName}/${item.name}`
-        });
-      } else {
-        options.imports.push(`import ${item.name} from '${packageName}'`);
-        silgi.options._installedModules.push({
-          meta,
-          entryPath: item.path,
-          packageName
-        });
-      }
-    } else {
-      const relativeRootDir = relativeWithDot(silgi.options.silgiDir, item.path);
-      options.imports.push(`import ${item.name} from '${relativeRootDir}'`);
-      silgi.options._installedModules.push({
-        meta,
-        entryPath: item.path,
-        packageName: item.path
-      });
-    }
-  });
-}
-async function modulesPackagesImport(silgi) {
-  const modules = [
-    ...silgi.options.modules,
-    ...silgi.options._modules
-  ];
-  const jiti = createJiti(silgi.options.rootDir);
-  for (const module of modules) {
-    const { resolvedModulePaths } = await loadCLISilgiModuleInstance(module, silgi);
-    for (const item of resolvedModulePaths || []) {
-      await loadCLISilgiModule(jiti, item, module, silgi, module);
-    }
-  }
-}
-async function modulesImport(silgi) {
-  const isPackage = silgi.options.isPackage ? `${silgi.options.dir.modules}/**/module.ts` : silgi.options.dir.modules;
-  const files = (await globby(isPackage, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
-  const jiti = createJiti(silgi.options.rootDir);
-  for (const file of files) {
-    const { resolvedModulePaths } = await loadCLISilgiModuleInstance(file, silgi);
-    for (const item of resolvedModulePaths || []) {
-      await loadCLISilgiModule(jiti, item, file, silgi);
-    }
-  }
-}
-async function installCLIModules(silgi) {
-  await modulesPackagesImport(silgi);
-  await modulesImport(silgi);
-  function createDependencyGraph(modules2) {
-    const graph2 = /* @__PURE__ */ new Map();
-    modules2.forEach((module) => {
-      const key = module.meta?.configKey;
-      if (key) {
-        graph2.set(key, /* @__PURE__ */ new Set());
-      }
-    });
-    modules2.forEach((module) => {
-      const key = module.meta?.configKey;
-      const deps = module.meta?.dependencies || [];
-      if (key && deps.length > 0) {
-        const modulesDeps = graph2.get(key) || /* @__PURE__ */ new Set();
-        deps.forEach((dep) => {
-          if (graph2.has(dep)) {
-            modulesDeps.add(dep);
-          }
-        });
-        graph2.set(key, modulesDeps);
-      }
-    });
-    return graph2;
-  }
-  function topologicalSort(graph2) {
-    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 = graph2.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 graph2.entries()) {
-      if (deps.size === 0 && !visited.has(node)) {
-        visit(node);
-      }
-    }
-    for (const node of graph2.keys()) {
-      if (!visited.has(node)) {
-        visit(node);
-      }
-    }
-    return order;
-  }
-  const moduleMap = new Map(
-    silgi.options._installedModules.map((m) => [m.meta?.configKey, m])
-  );
-  const graph = createDependencyGraph(silgi.options._installedModules);
-  const sortedKeys = topologicalSort(graph);
-  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
-  silgi.options._installedModules = modules;
-  silgi.hook("prepare:core.ts", async (options) => {
-    for (const module of silgi.options._installedModules) {
-      options.modules.push(module.meta.configKey);
-    }
-  });
-  silgi.hook("prepare:schema.ts", async (options) => {
-    for (const module of silgi.options._installedModules) {
-      const exports = module.meta.exports;
-      if (exports?.interface) {
-        let importName;
-        options.importedItems[module.meta.configKey] = {
-          import: [],
-          from: module.packageName
-        };
-        if (exports.interface.config) {
-          importName = pascalCase(`${module.meta.configKey}Config`);
-          options.importedItems[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.importedItems[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.importedItems[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.importedItems[module.meta.configKey].import.push({
-            name: `SilgiModuleShared as ${importName}`,
-            type: true
-          });
-          options.shareds.push({
-            key: module.meta.configKey,
-            value: importName
-          });
-        }
-      }
-    }
-  });
-}
-
-async function generate$1(mergeConfig) {
-  const hooks = createHooks();
-  const silgi = {
-    services: {},
-    shared: {},
-    uris: {},
-    _initializedModules: {},
-    scannedHandlers: /* @__PURE__ */ new Map(),
-    schemas: {},
-    storage: undefined,
-    hooks,
-    callHook: hooks.callHook,
-    addHooks: hooks.addHooks,
-    hook: hooks.hook,
-    ready: () => {
-      return hooks.callHook("ready", silgi);
-    },
-    close: () => hooks.callHook("close", silgi),
-    options: mergeConfig,
-    _version: "v0",
-    hooksNames: null,
-    logger: null
-  };
-  silgi._ignore = ignore(silgi.options.ignoreOptions);
-  silgi.hook("prepare:types", (opts) => {
-    opts.references.push({ path: resolve(silgi.options.buildDir, "./schema.d.ts") });
-    opts.references.push({ path: resolve(silgi.options.buildDir, "./h3.d.ts") });
-    opts.references.push({ path: resolve(silgi.options.buildDir, "./silgi-routes.d.ts") });
-  });
-  await generateUris(silgi);
-  await generateSilgiStorageBaseType(silgi);
-  await installCLIModules(silgi);
-  await scanFiles(silgi);
-  await writeTypes(silgi);
-  await silgi.callHook("read:core.ts", async () => {
-    const data = await readSilgiTs(silgi);
-    return data;
-  });
-  return silgi;
-}
-
-const generate = defineCommand({
-  meta: {
-    name: "Silgi Generate",
-    description: "Generate code",
-    version: "0.1.0"
-  },
-  args: {},
-  async run() {
-    const mergeConfig = await loadSilgiConfig({
-      overrides: {
-        dev: true
-      }
-    });
-    const silgi = await generate$1(mergeConfig);
-    await silgi.close();
-  }
-});
-
-export { generate as default };