silgi 0.20.28 → 0.20.30

package/dist/_chunks/index.mjs

@@ -1,4 +1,4 @@
-const version = "0.20.28";
+const version = "0.20.30";
 const peerDependencies = {
 	"@fastify/deepmerge": "^3.0.0",
 	"@nuxt/kit": "^3.15.3",

package/dist/cli/common.mjs

@@ -342,147 +342,125 @@ async function nuxtFramework(silgi, skip = false) {
 const frameworkSetup = [emptyFramework, h3Framework, nitroFramework, nuxtFramework];
 
 async function registerModuleExportScan(silgi) {
-  for (const module of silgi.scanModules) {
-    const moduleReExports = [];
-    const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
-    const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
-    for (const e of findTypeExports(normalisedModuleTypes)) {
-      moduleReExports.push(e);
-    }
-    for (const e of findExports(normalisedModuleTypes)) {
-      moduleReExports.push(e);
-    }
-    const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
-    const configKey = module.meta.configKey;
-    const moduleName = module.meta.name || module.meta._packageName;
-    silgi.hook("prepare:schema.ts", async (options) => {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    for (const module of silgi.scanModules) {
+      const moduleReExports = [];
+      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
+      const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
+      for (const e of findTypeExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      for (const e of findExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
+      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)
       };
-    });
-    if (hasTypeExport("ModuleOptions")) {
-      const importName = `_${hash(`${configKey}ModuleOptions`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      if (hasTypeExport("ModuleOptions")) {
+        const importName = `_${hash(`${configKey}ModuleOptions`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleOptions as ${importName}`,
           type: true,
           key: importName
         });
         options.options.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeOptions")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeOptions`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeOptions")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeOptions`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeOptions as ${importName}`,
           type: true,
           key: importName
         });
         options.runtimeOptions.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeShareds")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeShareds`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeShareds")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeShareds`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeShareds as ${importName}`,
           type: true,
           key: importName
         });
         options.shareds.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleEvents")) {
-      const importName = `_${hash(`${configKey}ModuleEvents`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleEvents")) {
+        const importName = `_${hash(`${configKey}ModuleEvents`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleEvents as ${importName}`,
           type: true,
           key: importName
         });
         options.events.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeContexts")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeContexts`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeContexts")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeContexts`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeContexts as ${importName}`,
           type: true,
           key: importName
         });
         options.contexts.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleHooks")) {
-      const importName = `_${hash(`${configKey}ModuleHooks`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleHooks")) {
+        const importName = `_${hash(`${configKey}ModuleHooks`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleHooks as ${importName}`,
           type: true,
           key: importName
         });
         options.hooks.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeHooks")) {
-      const importName = `_${hash(`${configKey}RuntimeHooks`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeHooks")) {
+        const importName = `_${hash(`${configKey}RuntimeHooks`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeHooks as ${importName}`,
           type: true,
           key: importName
         });
         options.runtimeHooks.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeActions")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeActions`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeActions")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeActions`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeActions as ${importName}`,
           type: true,
           key: importName
         });
         options.actions.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeMethods")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeMethods`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeMethods")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeMethods`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeMethods as ${importName}`,
           type: true,
           key: importName
         });
         options.methods.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeRouteRules")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeRouteRules`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeRouteRules")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRules`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeRouteRules as ${importName}`,
           type: true,
           key: importName
         });
         options.routeRules.push({ key: configKey, value: importName });
-      });
-    }
-    if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
-      const importName = `_${hash(`${configKey}ModuleRuntimeRouteRulesConfig`)}`;
-      silgi.hook("prepare:schema.ts", async (options) => {
+      }
+      if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
+        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRulesConfig`)}`;
         options.importItems[configKey].import.push({
           name: `ModuleRuntimeRouteRulesConfig as ${importName}`,
           type: true,
           key: importName
         });
         options.routeRulesConfig.push({ key: configKey, value: importName });
-      });
+      }
     }
-  }
+  });
 }
 
 async function loadSilgiModuleInstance(silgiModule) {
@@ -945,10 +923,6 @@ async function prepareServerFiles(silgi) {
     defu$1(scanned.modulesURIs, silgi.modulesURIs);
   }
   await silgi.callHook("prepare:scan.ts", scanned);
-  scanned.services = [...new Set(scanned.services)];
-  scanned.shareds = [...new Set(scanned.shareds)];
-  scanned.schemas = [...new Set(scanned.schemas)];
-  scanned.customImports = [...new Set(scanned.customImports)];
   if (importItems["#silgi/vfs"].import.length === 0) {
     delete importItems["#silgi/vfs"];
   }
@@ -1265,136 +1239,77 @@ async function scanFiles$1(silgi, watchFiles) {
       if (hasError("Parser", silgi)) {
         return;
       }
+      const scanTS = [];
+      const schemaTS = [];
       if (createServices.length > 0) {
-        for (const createService of createServices) {
-          const { exportName, path } = createService;
+        scanTS.push(...createServices.map(({ exportName, path }) => {
           silgi.options.devServer.watch.push(path);
           const randomString = hash(basename(path) + exportName);
           const _name = `_v${randomString}`;
-          silgi.hook("prepare:scan.ts", (options) => {
-            options.services.push(_name);
-          });
-          silgi.hook("prepare:scan.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              key: _name
-            });
-          });
-        }
+          return { exportName, path, _name, type: "service" };
+        }));
       }
       const createSchemas = exportVariables("createSchema", filePath);
       if (hasError("Parser", silgi)) {
         return;
       }
       if (createSchemas.length > 0) {
-        for (const createSchema of createSchemas) {
-          const { exportName, path } = createSchema;
+        scanTS.push(...createSchemas.map(({ exportName, path }) => {
           silgi.options.devServer.watch.push(path);
           const randomString = hash(basename(path) + exportName);
           const _name = `_v${randomString}`;
-          silgi.hook("prepare:scan.ts", (options) => {
-            options.schemas.push(_name);
-          });
-          silgi.hook("prepare:scan.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              key: _name
-            });
-          });
-        }
+          return { exportName, path, _name, type: "schema" };
+        }));
       }
       const createShareds = exportVariables("createShared", filePath);
       if (hasError("Parser", silgi)) {
         return;
       }
       if (createShareds.length > 0) {
-        for (const createShared of createShareds) {
-          const { exportName, path } = createShared;
+        scanTS.push(...createShareds.map(({ exportName, path }) => {
           silgi.options.devServer.watch.push(path);
           const randomString = hash(basename(path) + exportName);
           const _name = `_v${randomString}`;
-          silgi.hook("prepare:scan.ts", (options) => {
-            options.shareds.push(_name);
-          });
-          silgi.hook("prepare:scan.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} as ${_name}`,
-              key: _name
-            });
-          });
-        }
+          return { exportName, path, _name, type: "shared" };
+        }));
       }
       const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
       if (hasError("Parser", silgi)) {
         return;
       }
       if (sharedsTypes.length > 0) {
-        for (const sharedType of sharedsTypes) {
-          const { exportName, path } = sharedType;
+        schemaTS.push(...sharedsTypes.map(({ exportName, path }) => {
           silgi.options.devServer.watch.push(path);
           const randomString = hash(basename(path) + exportName);
           const _name = `_v${randomString}`;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.shareds.push({
-              key: _name,
-              value: _name
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              type: true,
-              key: _name
-            });
-          });
-        }
+          return { exportName, path, _name, type: "shared" };
+        }));
       }
       const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
       if (hasError("Parser", silgi)) {
         return;
       }
       if (contextTypes.length > 0) {
-        for (const contextType of contextTypes) {
-          const { exportName, path } = contextType;
+        schemaTS.push(...contextTypes.map(({ exportName, path }) => {
           silgi.options.devServer.watch.push(path);
           const randomString = hash(basename(path) + exportName);
           const _name = `_v${randomString}`;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.contexts.push({
-              key: _name,
-              value: _name
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: `${exportName} as ${_name}`,
-              type: true,
-              key: _name
-            });
+          return { exportName, path, _name, type: "context" };
+        }));
+      }
+      silgi.hook("prepare:scan.ts", (options) => {
+        for (const { exportName, path, _name, type } of scanTS) {
+          options.schemas.push(_name);
+          options.importItems[path] ??= {
+            import: [],
+            from: relativeWithDot(silgi.options.silgi.serverDir, path)
+          };
+          options.importItems[path].import.push({
+            name: `${exportName} as ${_name}`,
+            key: _name
           });
         }
-      }
+      });
     }
   }
 }

package/dist/meta/index.d.mts

@@ -1,4 +1,4 @@
-const version = "0.20.28";
+const version = "0.20.30";
 const peerDependencies = {
 	"@fastify/deepmerge": "^3.0.0",
 	"@nuxt/kit": "^3.15.3",

package/dist/meta/index.d.ts

@@ -1,4 +1,4 @@
-const version = "0.20.28";
+const version = "0.20.30";
 const peerDependencies = {
 	"@fastify/deepmerge": "^3.0.0",
 	"@nuxt/kit": "^3.15.3",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.20.28",
+  "version": "0.20.30",
   "private": false,
   "sideEffects": false,
   "exports": {