silgi 0.5.0 → 0.7.0

package/dist/cli/prepare.mjs

@@ -2,25 +2,20 @@ 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 { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
 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 { silgiGenerateType, useSilgiCLI, SchemaParser, loadOptions, silgiCLICtx } from 'silgi/core';
+import { relativeWithDot, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1, normalizeTemplate, useLogger } from 'silgi/kit';
+import { toExports, scanExports, createUnimport } from 'unimport';
+import { createJiti } from 'dev-jiti';
 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 { h as hasInstalledModule } from './compatibility.mjs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { isRelative, withTrailingSlash } from 'ufo';
 import { globby } from 'globby';
@@ -28,7 +23,6 @@ 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)
@@ -61,14 +55,14 @@ async function h3Framework(silgi, skip = false) {
   silgi.hook("prepare:createDTSFramework", (data) => {
     data.importItems["silgi/types"] = {
       import: [
-        { name: "SilgiModuleContext", type: true }
+        { name: "ModuleRuntimeContext", type: true }
       ],
       from: "silgi/types"
     };
     data.customContent?.push(
       "",
       'declare module "h3" {',
-      "  interface H3EventContext extends SilgiModuleContext {}",
+      "  interface H3EventContext extends ModuleRuntimeContext {}",
       "}",
       ""
     );
@@ -93,6 +87,8 @@ async function nitroFramework(silgi, skip = false) {
     packageImport: "silgi/runtime/internal/nitro",
     path: join(runtimeDir, "internal/nitro")
   });
+  silgi.hook("prepare:core.ts", (_data) => {
+  });
   await h3Framework(silgi, true);
 }
 
@@ -104,28 +100,121 @@ async function nuxtFramework(silgi, skip = false) {
 
 const frameworkSetup = [h3Framework, nitroFramework, nuxtFramework];
 
-async function prepare$1(silgi) {
-  await prepareDir(silgi.options.output.dir);
+async function prepare$1(_silgi) {
+}
+
+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 prepareDir(dir) {
-  await fsp.rm(dir, { recursive: true, force: true });
-  await fsp.mkdir(dir, { recursive: true });
+
+async function generateRouterDTS(silgi) {
+  silgi.hook("finish:types", async (data) => {
+    const uris = data.object.uris;
+    const subPath = "srn";
+    const groupedPaths = /* @__PURE__ */ new Map();
+    Object.entries(uris || {}).forEach(([key, params]) => {
+      const [service, resource, method, action] = key.split("/");
+      const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
+      const fullPath = `${subPath}/${service}/${resource}/${action}`;
+      if (!groupedPaths.has(basePath)) {
+        groupedPaths.set(basePath, /* @__PURE__ */ new Map());
+      }
+      groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
+    });
+    const keys = [
+      "  keys: {",
+      Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
+        return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
+      ${method}: '/${path}'`).join(",")}
+    }`;
+      }).join(",\n"),
+      "  }",
+      ""
+    ].join("\n");
+    const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
+      const [service, resource, method, action] = key.split("/");
+      const routePath = `${subPath}/${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 content = [
+      keys.slice(0, -1),
+      // son satırdaki boş satırı kaldır
+      ...routerTypes
+    ].join(",\n");
+    const context = [
+      "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractRouterParamsFromURI } from 'silgi/types'",
+      "",
+      "export interface RouterTypes {",
+      content,
+      "}",
+      "",
+      "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 readCoreFile(silgi) {
   const path = resolve(silgi.options.silgi.serverDir, "core.ts");
+  const context = await promises.readFile(path, { encoding: "utf-8" });
+  const injectedResult = await silgi.unimport.injectImports(context, path);
+  if (!injectedResult) {
+    throw new Error("Failed to inject imports");
+  }
   const jiti = createJiti(silgi.options.rootDir, {
     fsCache: false,
-    interopDefault: true,
     moduleCache: false,
+    debug: silgi.options.debug,
     alias: silgi.options.alias
   });
-  const resolvedPath = jiti.esmResolve(path);
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  const coreFile = await jiti.import(
-    resolvedPath,
+  const coreFile = await jiti.evalModule(
+    injectedResult.code,
     {
+      filename: path,
+      async: true,
       conditions: silgi.options.conditions
+    },
+    async (data, name) => {
+      return (await silgi.unimport.injectImports(data, name)).code;
     }
   );
   silgi.uris = coreFile.uris;
@@ -156,7 +245,7 @@ function traverseObject(silgi, obj, currentPath = []) {
       let paramString = "";
       if (node.router) {
         let params = null;
-        if (node.router?._def?.typeName !== undefined) {
+        if (node.router?._def?.typeName !== void 0) {
           try {
             const shape = node.router?.shape?.params?.shape;
             params = shape ? Object.keys(shape) : null;
@@ -188,16 +277,19 @@ function scanActionModulesUris(silgi, obj, currentPath = []) {
     if (path.length === 4) {
       const basePath = path.join("/");
       let moduleName = "";
-      if (node.modules?.graphqlyoga) {
+      if (node.modules?.yoga) {
         let rootFieldName = null;
-        if (node.modules?.graphqlyoga?.rootFieldName) {
-          moduleName = "graphqlyoga";
-          rootFieldName = node.modules?.graphqlyoga?.rootFieldName;
+        if (node.modules?.yoga?.rootFieldName) {
+          moduleName = "yoga";
+          rootFieldName = node.modules?.yoga?.rootFieldName;
         }
         if (!rootFieldName) {
           return;
         }
         uriMap[moduleName] ??= {};
+        if (uriMap[moduleName].rootFieldName) {
+          silgi.logger.withTag("scanActionModulesUris").error(`Hata ${moduleName} ${rootFieldName} ${basePath} bu zaten burada kullanilmis.`);
+        }
         uriMap[moduleName].rootFieldName ??= {};
         uriMap[moduleName].rootFieldName[rootFieldName] = basePath;
       }
@@ -235,99 +327,6 @@ ${uriContent}
   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 subPath = "srn";
-      const groupedPaths = /* @__PURE__ */ new Map();
-      Object.entries(uris || {}).forEach(([key, params]) => {
-        const [service, resource, method, action] = key.split("/");
-        const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
-        const fullPath = `${subPath}/${service}/${resource}/${action}`;
-        if (!groupedPaths.has(basePath)) {
-          groupedPaths.set(basePath, /* @__PURE__ */ new Map());
-        }
-        groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
-      });
-      const keys = [
-        "  keys: {",
-        Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
-          return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
-      ${method}: '/${path}'`).join(",")}
-    }`;
-        }).join(",\n"),
-        "  }",
-        ""
-      ].join("\n");
-      const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
-        const [service, resource, method, action] = key.split("/");
-        const routePath = `${subPath}/${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 content = [
-        keys.slice(0, -1),
-        // son satırdaki boş satırı kaldır
-        ...routerTypes
-      ].join(",\n");
-      const context = [
-        "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractRouterParamsFromURI } from 'silgi/types'",
-        "",
-        "export interface RouterTypes {",
-        content,
-        "}",
-        "",
-        "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")
@@ -335,7 +334,7 @@ async function createCoreFramework(silgi) {
   const importItems = {
     "silgi/types": {
       import: [
-        { name: "SilgiModuleContext", type: true }
+        { name: "ModuleRuntimeContext", type: true }
       ],
       from: "silgi/types"
     }
@@ -360,7 +359,7 @@ async function createCoreFramework(silgi) {
     functions
   });
   const content = [
-    ...functions.map((f) => ` await ${f}(framework)`)
+    ...functions.map((f) => f.params?.length ? ` await ${f.name}(framework, ${f.params.join(",")})` : ` await ${f.name}(framework)`)
   ];
   return {
     content,
@@ -373,7 +372,7 @@ async function createDTSFramework(silgi) {
   const importItems = {
     "silgi/types": {
       import: [
-        { name: "SilgiModuleContext", type: true }
+        { name: "ModuleRuntimeContext", type: true }
       ],
       from: "silgi/types"
     }
@@ -421,7 +420,7 @@ async function schemaTemplate(silgi) {
       import: [
         { name: "URIsTypes", type: true },
         { name: "Namespaces", type: true },
-        { name: "SilgiModuleContext", type: true }
+        { name: "ModuleRuntimeContext", type: true }
       ],
       from: "silgi/types"
     }
@@ -438,23 +437,20 @@ async function schemaTemplate(silgi) {
       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", {
+  const data = {
     importItems,
-    customImports,
-    configs,
-    contexts,
-    methods,
-    shareds,
-    storeBase,
-    events
-  });
+    customImports: [],
+    configs: [],
+    contexts: [],
+    methods: [],
+    shareds: [],
+    events: [],
+    storeBase: [],
+    hooks: [],
+    runtimeHooks: []
+  };
+  const storeBase = [];
+  await silgi.callHook("prepare:schema.ts", data);
   const silgiExport = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
   let addSilgiContext = false;
   const importsContent = [
@@ -463,7 +459,7 @@ async function schemaTemplate(silgi) {
       return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
     }),
     "",
-    ...customImports,
+    ...data.customImports,
     ""
   ];
   const importData = [
@@ -475,31 +471,34 @@ async function schemaTemplate(silgi) {
     "",
     `type SilgiURIsMerge = URIsTypes<typeof import('${silgiExport}')['uris']>`,
     "",
-    contexts.length ? `type SilgiModuleContextExtends = ${contexts.map(({ value }) => value).join(" & ")}` : "type SilgiModuleContextExtends = {}",
+    `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
     "",
-    events.length ? `interface SilgiModuleEventsExtends extends ${events.map((item) => item.extends ? item.value : "").join(", ")} {
-      ${events.map((item) => {
+    data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${data.events.map((item) => {
       if (item.isSilgiContext) {
         addSilgiContext = true;
       }
-      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: SilgiModuleContext" : "";
+      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: ModuleRuntimeContext" : "";
     }).join(",\n")}
 }` : "interface SilgiModuleEventsExtends {}",
     "",
-    shareds.length ? `type SilgiModuleSharedExtends = ${shareds.map(({ value }) => value).join(" & ")}` : "type SilgiModuleSharedExtends = {}",
+    data.shareds.length ? `type SilgiModuleSharedExtends = ${data.shareds.map(({ value }) => value).join(" & ")}` : "type SilgiModuleSharedExtends = {}",
     "",
     "interface SilgiModuleMethodsExtends {",
-    ...(methods).map(({ key, value }) => `  ${key}: ${value},`),
+    ...(data.methods || []).map(({ key, value }) => `  ${key}: ${value},`),
     "}",
     "",
     "interface SilgiModuleOptionsExtends {",
-    ...(configs).map(({ key, value }) => `  ${key}: ${value},`),
+    ...(data.configs || []).map(({ key, value }) => `  ${key}: ${value},`),
     "}",
     "",
     "interface SilgiStorageBaseExtends {",
-    ...(storeBase).map((value) => `  ${value}: ''`),
+    ...(storeBase || []).map((value) => `  ${value}: ''`),
     "}",
     "",
+    `type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
     "",
     "declare module 'silgi/types' {",
     " interface FrameworkContext extends FrameworkContextExtends {}",
@@ -508,11 +507,13 @@ async function schemaTemplate(silgi) {
     " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
     " interface SilgiModules extends SilgiModuleOptionsExtends {}",
     " interface SilgiURIs extends SilgiURIsMerge {}",
-    " interface SilgiModuleContext extends SilgiModuleContextExtends {}",
+    " interface ModuleRuntimeContext extends SilgiModuleContextExtends {}",
     " interface SilgiEvent extends SilgiModuleEventsExtends {}",
     " interface SilgiDefaultShared extends SilgiModuleSharedExtends {}",
-    " interface SilgiModuleMethods extends SilgiModuleMethodsExtends {}",
-    " interface SilgiModuleOptions extends SilgiModuleOptionsExtends {}",
+    " interface ModuleRuntimeMethods extends SilgiModuleMethodsExtends {}",
+    " interface ModuleOptions extends SilgiModuleOptionsExtends {}",
+    " interface ModuleRuntimeHooks extends SilgiRuntimeHooksExtends {}",
+    " interface ModuleHooks extends ModuleHooksExtend {}",
     "}",
     "",
     "export {}"
@@ -533,11 +534,17 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
     },
     "silgi/types": {
       import: [
-        { name: "SilgiModuleOptions", type: true },
+        { name: "ModuleOptions", type: true },
         { name: "SilgiOptions", type: true },
-        { name: "FrameworkContext", type: true }
+        { name: "FrameworkContext", type: true },
+        { name: "DeepPartial", type: true },
+        { name: "BuildConfig", type: true }
       ],
       from: "silgi/types"
+    },
+    "#silgi/vfs": {
+      import: [],
+      from: "./vfs"
     }
   };
   importItems = { ...data._importItems, ...importItems };
@@ -559,6 +566,13 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
   const shareds = [];
   const schemas = [];
   const buildSilgiExtraContent = [];
+  const _silgiOptions = {};
+  const _silgiConfigs = [];
+  for (const module of silgi.scanModules) {
+    _silgiOptions[module.meta.configKey] = {
+      ...module.options
+    };
+  }
   await silgi.callHook("prepare:core.ts", {
     importItems,
     customImports,
@@ -566,8 +580,13 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
     services,
     shareds,
     schemas,
-    buildSilgiExtraContent
+    buildSilgiExtraContent,
+    _silgiOptions,
+    _silgiConfigs
   });
+  if (importItems["#silgi/vfs"].import.length === 0) {
+    delete importItems["#silgi/vfs"];
+  }
   if (services.length > 0) {
     importItems["silgi/core"].import.push({ name: "mergeServices" });
   }
@@ -580,13 +599,14 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
   const plugins = [];
   for (const plugin of silgi.options.plugins) {
     const pluginImportName = `_${hash(plugin.packageImport)}`;
-    customImports.push(`import ${pluginImportName} from '${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,
     ""
   ];
@@ -613,9 +633,9 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
     }),
     shareds.length > 0 ? "])" : "}",
     "",
+    `export const _silgiOptions: DeepPartial<ModuleOptions> = ${JSON.stringify(_silgiOptions, null, 2)}`,
     "",
-    "export async function buildSilgi(framework: FrameworkContext, options?: Partial<SilgiModuleOptions>) {",
-    "  try {",
+    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<ModuleOptions>,buildOptions?: Partial<BuildConfig>, ) {",
     "  const silgi = await createSilgi({",
     "      framework,",
     "      shared: shareds as any,",
@@ -624,10 +644,12 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
     "      uris,",
     "      modulesURIs,",
     `      plugins: [${plugins.join(", ")}],`,
-    "",
+    _silgiConfigs.length > 0 ? `      ${_silgiConfigs.map((config) => Object.entries(config).map(([key, value]) => `${key}: ${value}`)).join(",\n      ")},` : "",
+    "      ...buildOptions,",
     "      options: {",
     `      present: '${silgi.options.preset}',`,
-    "      ...options,",
+    "      ..._silgiOptions,",
+    "      ...moduleOptions,",
     "     },",
     "    })",
     "",
@@ -636,9 +658,6 @@ async function silgiCoreFile(data, frameworkContext, silgi) {
     ...buildSilgiExtraContent,
     "",
     "  return silgi",
-    "  } catch (error) {",
-    "    throw new Error(error.message)",
-    "  }",
     "}",
     ""
   ];
@@ -745,14 +764,19 @@ async function writeTypesAndFiles(silgi) {
     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
-      );
-    })
-  );
+  for await (const file of buildFiles) {
+    await writeFile(
+      resolve(silgi.options.build.dir, file.path),
+      file.contents
+    );
+  }
+  await scanUris(silgi);
+  const readCore = await readCoreFile(silgi);
+  silgi.uris = readCore.object.uris;
+  silgi.modulesURIs = readCore.object.modulesURIs;
+  silgi.schemas = readCore.object.schemas;
+  silgi.shareds = readCore.object.shareds;
+  await silgi.hooks.callHook("finish:types", readCore);
 }
 
 const commonArgs = {
@@ -767,133 +791,71 @@ const commonArgs = {
   }
 };
 
-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) {
+async function registerModuleExportScan(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.name || 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
-          });
-        }
+      if (!exports?.length)
+        continue;
+      const configKey = module.meta.configKey;
+      const moduleName = module.meta.name || module.meta._packageName;
+      options.importItems[configKey] = {
+        import: [],
+        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
+      };
+      const exportedTypes = exports.filter((exp) => exp.type).map((exp) => exp.name);
+      if (exportedTypes.includes("ModuleOptions")) {
+        const importName = pascalCase(`${configKey}Config`);
+        options.importItems[configKey].import.push({
+          name: `ModuleOptions as ${importName}`,
+          type: true
+        });
+        options.configs.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeContext")) {
+        const importName = pascalCase(`${configKey}Context`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeContext as ${importName}`,
+          type: true
+        });
+        options.contexts.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeMethods")) {
+        const importName = pascalCase(`${configKey}Method`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeMethods as ${importName}`,
+          type: true
+        });
+        options.methods.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeShared")) {
+        const importName = pascalCase(`${configKey}Shared`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeShared as ${importName}`,
+          type: true
+        });
+        options.shareds.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleHooks")) {
+        const importName = pascalCase(`${configKey}Hooks`);
+        options.importItems[configKey].import.push({
+          name: `ModuleHooks as ${importName}`,
+          type: true
+        });
+        options.hooks.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeHooks")) {
+        const importName = pascalCase(`${configKey}RuntimeHooks`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeHooks as ${importName}`,
+          type: true
+        });
+        options.runtimeHooks.push({ key: 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?`);
@@ -941,7 +903,7 @@ async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptio
   }
 }
 
-const logger = consola;
+const logger$1 = consola;
 async function _resolveSilgiModule(mod, silgi) {
   let _url;
   let buildTimeModuleMeta = {};
@@ -954,7 +916,6 @@ async function _resolveSilgiModule(mod, silgi) {
     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) {
@@ -971,8 +932,10 @@ async function _resolveSilgiModule(mod, silgi) {
         } else {
           if (typeof mod === "function") {
             const meta = await mod.getMeta?.();
+            const _exports = await scanExports(_url, true);
             buildTimeModuleMeta = {
-              ...meta
+              ...meta,
+              exports: _exports.map(({ from, ...rest }) => rest)
             };
           }
         }
@@ -982,7 +945,7 @@ async function _resolveSilgiModule(mod, silgi) {
         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}`);
+        logger$1.error(`Error while importing module \`${mod}\`: ${error}`);
         throw error;
       }
     }
@@ -991,10 +954,14 @@ async function _resolveSilgiModule(mod, silgi) {
     throw new Error(`Module ${mod} is not a valid Silgi module`);
   }
   if (typeof mod === "function") {
+    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
+      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
+    }
     silgi.scanModules.push({
       meta: buildTimeModuleMeta,
       entryPath: _url,
-      installed: false
+      installed: false,
+      options: await mod.getOptions?.() || {}
     });
   }
 }
@@ -1042,9 +1009,8 @@ function topologicalSort(graph) {
   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 (temp.has(node))
+      throw new Error(`Circular dependency detected: ${node}`);
     if (visited.has(node))
       return;
     temp.add(node);
@@ -1054,17 +1020,15 @@ function topologicalSort(graph) {
     }
     temp.delete(node);
     visited.add(node);
-    order.push(node);
+    order.unshift(node);
   }
   for (const [node, deps] of graph.entries()) {
-    if (deps.size === 0 && !visited.has(node)) {
+    if (deps.size === 0 && !visited.has(node))
       visit(node);
-    }
   }
   for (const node of graph.keys()) {
-    if (!visited.has(node)) {
+    if (!visited.has(node))
       visit(node);
-    }
   }
   return order;
 }
@@ -1263,6 +1227,122 @@ async function createStorageCLI(silgi) {
   return storage;
 }
 
+const vueShim = {
+  filename: "types/vue-shim.d.ts",
+  getContents: ({ app }) => {
+    if (!app.options.typescript.shim) {
+      return "";
+    }
+    return [
+      "declare module '*.vue' {",
+      "  import { DefineComponent } from 'vue'",
+      "  const component: DefineComponent<{}, {}, any>",
+      "  export default component",
+      "}"
+    ].join("\n");
+  }
+};
+const pluginsDeclaration = {
+  filename: "types/plugins.d.ts",
+  getContents: async () => {
+    return `
+      declare module 'nuxt' {
+        interface NuxtApp {
+          $myPlugin: any;
+        }
+      }
+    `;
+  }
+};
+
+const defaultTemplates = {
+  __proto__: null,
+  pluginsDeclaration: pluginsDeclaration,
+  vueShim: vueShim
+};
+
+const postTemplates = [
+  pluginsDeclaration.filename
+];
+const logger = useLogger("silgi");
+async function generateApp(app, options = {}) {
+  app.templates = Object.values(defaultTemplates).concat(app.options.build.templates);
+  await app.callHook("app:templates", app);
+  app.templates = app.templates.map((tmpl) => normalizeTemplate(tmpl, app.options.silgi.vfsDir));
+  const filteredTemplates = {
+    pre: [],
+    post: []
+  };
+  for (const template of app.templates) {
+    if (options.filter && !options.filter(template)) {
+      continue;
+    }
+    const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
+    filteredTemplates[key].push(template);
+  }
+  const templateContext = { app };
+  const writes = [];
+  const indexImports = [];
+  const dirs = /* @__PURE__ */ new Set();
+  const changedTemplates = [];
+  async function processTemplate(template) {
+    const fullPath = template.dst || resolve(app.options.silgi.vfsDir, template.filename);
+    const start = performance.now();
+    const contents = await compileTemplate(template, templateContext).catch((e) => {
+      logger.error(`Could not compile template \`${template.filename}\`.`);
+      logger.error(e);
+      throw e;
+    });
+    template.modified = true;
+    if (template.modified) {
+      changedTemplates.push(template);
+    }
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (app.options.debug || setupTime > 500) {
+      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+    }
+    if (template.modified && template.write) {
+      dirs.add(dirname(fullPath));
+      if (!fullPath.endsWith(".d.ts")) {
+        indexImports.push(relativeWithDot(app.options.silgi.serverDir, fullPath));
+      }
+      writes.push(() => writeFileSync(fullPath, contents, "utf8"));
+    }
+  }
+  await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
+  await Promise.allSettled(filteredTemplates.post.map(processTemplate));
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const write of writes) {
+    write();
+  }
+  writeFileSync(resolve(app.options.silgi.serverDir, "index.ts"), `${indexImports.map((i) => `export * from '${i}'`).join("\n")}
+`, "utf8");
+  if (changedTemplates.length) {
+    await app.callHook("app:templatesGenerated", app, changedTemplates, options);
+  }
+}
+async function compileTemplate(template, ctx) {
+  delete ctx.utils;
+  if (template.src) {
+    try {
+      return await promises.readFile(template.src, "utf-8");
+    } catch (err) {
+      logger.error(`[nuxt] Error reading template from \`${template.src}\``);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents({
+      ...ctx,
+      options: template.options
+    });
+  }
+  throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
+}
+
 const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
 async function scanAndSyncOptions(silgi) {
   const scannedModules = await scanModules(silgi);
@@ -1274,7 +1354,7 @@ async function scanAndSyncOptions(silgi) {
   }
 }
 async function scanModules(silgi) {
-  const files = await scanFiles(silgi, "modules");
+  const files = await scanFiles(silgi, "silgi/modules");
   return files.map((f) => f.fullPath);
 }
 async function scanFiles(silgi, name) {
@@ -1308,15 +1388,16 @@ async function createSilgiCLI(config = {}, opts = {}) {
     uris: {},
     shareds: {},
     schemas: {},
-    unimport: undefined,
+    unimport: void 0,
     options,
     hooks,
     // vfs: {}
     _requiredModules: {},
     logger: consola.withTag("silgi"),
     close: () => silgi.hooks.callHook("close", silgi),
-    storage: undefined,
+    storage: void 0,
     scanModules: [],
+    templates: [],
     callHook: hooks.callHook,
     addHooks: hooks.addHooks,
     hook: hooks.hook,
@@ -1340,20 +1421,22 @@ async function createSilgiCLI(config = {}, opts = {}) {
   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) {
+  if (silgi.options.logLevel !== void 0) {
     silgi.logger.level = silgi.options.logLevel;
   }
+  silgi.hooks.addHooks(silgi.options.hooks);
   await installModules(silgi);
+  await silgi.hooks.callHook("scanFiles:done", silgi);
+  await generateApp(silgi);
   if (silgi.options.imports) {
     silgi.unimport = createUnimport(silgi.options.imports);
     await silgi.unimport.init();
   }
-  await afterModuleScan(silgi);
+  await registerModuleExportScan(silgi);
   return silgi;
 }
 
@@ -1368,17 +1451,25 @@ const prepare = defineCommand({
     preset: {
       type: "string",
       description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    stub: {
+      type: "boolean",
+      description: "Run in silgi development mode"
     }
   },
   async run({ args }) {
     const rootDir = resolve(args.dir || args._dir || ".");
-    const silgi = await createSilgiCLI({ rootDir });
-    await prepare$1(silgi);
+    const silgi = await createSilgiCLI({
+      rootDir,
+      dev: args.stub,
+      stub: args.stub,
+      typescript: { internalPaths: args.stub }
+    });
+    await prepare$1();
     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;