silgi 0.36.18 → 0.37.1

package/dist/build.mjs

@@ -26,6 +26,7 @@ import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
 import 'globby';
+import 'oxc-parser';
 import 'ignore';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/build.mjs

@@ -16,8 +16,9 @@ import { fileURLToPath } from 'node:url';
 import { defu } from 'defu';
 import { resolveModuleURL } from 'exsolve';
 import { withTrailingSlash, isRelative } from 'ufo';
-import { readFile, readdir } from 'node:fs/promises';
+import { readdir, readFile } from 'node:fs/promises';
 import { globby } from 'globby';
+import { parseAsync } from 'oxc-parser';
 import ignore from 'ignore';
 import { klona } from 'klona';
 import { useSilgiRuntimeConfig, initRuntimeConfig } from 'silgi/runtime';
@@ -574,44 +575,22 @@ function resolveGroupSyntax(group) {
   return groups;
 }
 
-const TYPE_DECLARATION_EXPORT_REGEX = /\bexport\s+(?<declaration>(interface|type|declare (async function|function|let|const enum|const|enum|var|class)))\s+(?<name>[\w$]+)(?:\s+extends\s+(?<extends>[\w$, \t\n\r]+))?/g;
-const FUNCTION_VARIABLE_EXPORT_REGEX = /\bexport\s+(?:const|let|var)\s+(?<name>[\w$]+)\s*=\s*(?<funcName>\w+)\s*\(/g;
-function extractExportMatches(regex, fileContent, additionalMetadata = {}) {
-  const matchedExports = [];
-  for (const match of fileContent.matchAll(regex)) {
-    const name = match.groups?.name || "";
-    const declaration = match.groups?.declaration || "";
-    const funcName = match.groups?.funcName || "";
-    const extendsClause = match.groups?.extends || "";
-    const codeSnippet = funcName ? `export const ${name} = ${funcName}(` : `export ${declaration} ${name}`;
-    const extendedTypes = extendsClause ? extendsClause.split(",").map((typeName) => typeName.trim()) : [];
-    matchedExports.push({
-      ...additionalMetadata,
-      name,
-      declaration,
-      funcName,
-      code: codeSnippet,
-      start: match.index,
-      end: (match.index || 0) + match[0].length,
-      extends: extendedTypes
-    });
-  }
-  return matchedExports;
-}
 function generateUniqueIdentifier(filePath, exportName) {
   const fileBaseName = basename(filePath);
   const uniqueString = `${fileBaseName}${exportName}`;
   return hash(uniqueString);
 }
-function categorizeExports(exportedEntities, filePath) {
+function categorizeExports(exportedEntities, filePath, functionExportCategories = {
+  createService: "service",
+  createSchema: "schema",
+  createShared: "shared",
+  createRoute: "route"
+}, interfaceExportCategories = {
+  ExtendShared: "shared",
+  ExtendContext: "context"
+}) {
   const runtimeExports = [];
   const typeExports = [];
-  const functionExportCategories = {
-    createService: "service",
-    createSchema: "schema",
-    createShared: "shared",
-    createRoute: "route"
-  };
   for (const [functionName, category] of Object.entries(functionExportCategories)) {
     const matchingExports = exportedEntities.filter((entity) => entity.funcName === functionName);
     for (const exportEntity of matchingExports) {
@@ -625,10 +604,6 @@ function categorizeExports(exportedEntities, filePath) {
       });
     }
   }
-  const interfaceExportCategories = {
-    ExtendShared: "shared",
-    ExtendContext: "context"
-  };
   for (const [extensionName, category] of Object.entries(interfaceExportCategories)) {
     const matchingExports = exportedEntities.filter(
       (entity) => entity.declaration === "interface" && entity.extends?.includes(extensionName)
@@ -725,13 +700,69 @@ async function verifyDirectoryCaseSensitivity(directoryPath, rootDirectory) {
   } catch {
   }
 }
-function stripCommentsAndStrings(code) {
-  return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/"([^"\\]|\\.)*"/g, '""').replace(/'([^'\\]|\\.)*'/g, "''").replace(/`([^`\\]|\\.)*`/g, "``");
+async function extractExportEntitiesFromFile(absoluteFilePath, functionExportNames = ["createSchema", "createService", "createRoute"], interfaceExtendsNames = ["ExtendShared", "ExtendContext"]) {
+  const exportEntities = [];
+  const fileContent = await readFile(absoluteFilePath, "utf-8");
+  const parsed = await parseAsync(absoluteFilePath, fileContent);
+  for (const node of parsed.program.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "TSInterfaceDeclaration") {
+      const decl = node.declaration;
+      if (Array.isArray(decl.extends) && decl.extends.some(
+        (dec) => dec.type === "TSInterfaceHeritage" && dec.expression.type === "Identifier" && interfaceExtendsNames.includes(dec.expression.name)
+      )) {
+        exportEntities.push({
+          name: decl.id?.name,
+          type: "interface",
+          declaration: "interface",
+          extends: decl.extends.filter((e) => e.type === "TSInterfaceHeritage" && e.expression.type === "Identifier").map((e) => e.expression.type === "Identifier" ? e.expression.name : false).filter((name) => Boolean(name))
+        });
+      }
+    }
+  }
+  for (const node of parsed.program.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+      const decls = node.declaration.declarations;
+      if (Array.isArray(decls)) {
+        for (const decl of decls) {
+          if (decl.type === "VariableDeclarator" && decl.id.type === "Identifier" && decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier" && functionExportNames.includes(decl.init.callee.name)) {
+            exportEntities.push({
+              name: decl.id.name,
+              type: "function",
+              funcName: decl.init.callee.name
+            });
+          }
+        }
+      }
+    }
+  }
+  return exportEntities;
 }
-async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()) {
+async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI(), scanOptions = {}) {
   const processedFilePaths = /* @__PURE__ */ new Set();
   const alreadyScannedPaths = [];
   const serverDirectory = path || silgiInstance.options.serverDir;
+  const functionExportNames = scanOptions.functionExportNames ?? ["createSchema", "createService", "createRoute"];
+  const interfaceExtendsNames = scanOptions.interfaceExtendsNames ?? ["ExtendShared", "ExtendContext"];
+  const functionExportCategories = {};
+  functionExportNames.forEach((name) => {
+    if (name === "createService")
+      functionExportCategories[name] = "service";
+    else if (name === "createSchema")
+      functionExportCategories[name] = "schema";
+    else if (name === "createShared")
+      functionExportCategories[name] = "shared";
+    else if (name === "createRoute")
+      functionExportCategories[name] = "route";
+    else functionExportCategories[name] = name;
+  });
+  const interfaceExportCategories = {};
+  interfaceExtendsNames.forEach((name) => {
+    if (name === "ExtendShared")
+      interfaceExportCategories[name] = "shared";
+    else if (name === "ExtendContext")
+      interfaceExportCategories[name] = "context";
+    else interfaceExportCategories[name] = name;
+  });
   if (!serverDirectory) {
     consola.warn("No server directory specified for scanning");
     return;
@@ -758,22 +789,17 @@ async function scanSilgiExports(path, packageName, silgiInstance = useSilgiCLI()
         continue;
       }
       try {
-        const fileContent = await readFile(absoluteFilePath, "utf-8");
-        const cleanedContent = stripCommentsAndStrings(fileContent);
-        const typeDeclarationExports = extractExportMatches(
-          TYPE_DECLARATION_EXPORT_REGEX,
-          cleanedContent,
-          { type: "declaration" }
-        );
-        const functionVariableExports = extractExportMatches(
-          FUNCTION_VARIABLE_EXPORT_REGEX,
-          cleanedContent,
-          { type: "variable" }
+        const exportEntities = await extractExportEntitiesFromFile(
+          absoluteFilePath,
+          functionExportNames,
+          interfaceExtendsNames
         );
-        const allExportedEntities = [...typeDeclarationExports, ...functionVariableExports];
+        const allExportedEntities = exportEntities;
         const { runtimeExports, typeExports } = categorizeExports(
           allExportedEntities,
-          absoluteFilePath
+          absoluteFilePath,
+          functionExportCategories,
+          interfaceExportCategories
         );
         registerExportsWithHooks(silgiInstance, runtimeExports, typeExports, packageName);
       } catch (error) {

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.36.18";
+const version = "0.37.1";
 const packageJson = {
 	version: version};
 

package/dist/cli/init.mjs

@@ -23,6 +23,7 @@ import 'defu';
 import 'exsolve';
 import 'ufo';
 import 'globby';
+import 'oxc-parser';
 import 'ignore';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/install.mjs

@@ -26,6 +26,7 @@ import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
 import 'globby';
+import 'oxc-parser';
 import 'ignore';
 import 'klona';
 import 'silgi/runtime';

package/dist/cli/watch.mjs

@@ -28,6 +28,7 @@ import 'exsolve';
 import 'ufo';
 import 'node:fs/promises';
 import 'globby';
+import 'oxc-parser';
 import 'ignore';
 import 'klona';
 import 'silgi/runtime';

package/dist/core/index.mjs

@@ -8,7 +8,6 @@ import { klona } from 'klona';
 import { useSilgiRuntimeConfig } from 'silgi/runtime';
 import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
 import { FastURL, FastResponse } from 'srvx';
-import { isRuntimePresents } from 'silgi/kit';
 export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
 
 const silgiCtx = getContext("silgi");
@@ -532,56 +531,73 @@ function getUrlPrefix(path, method) {
 }
 
 async function orchestrate(route, event) {
-  const input = await parseRequestInput(event.req);
   const silgiCtx = useSilgi();
   const silgiURL = getUrlPrefix(route.route, event.req.method);
+  const input = await parseRequestInput(event.req);
   try {
     const routerParams = getRouterParams(event);
     const queryParams = getQuery(event);
-    let success = false;
-    let cached = false;
-    let result;
     const setup = route.setup;
-    const cacheData = await cacheExecute(input, route, silgiURL, event);
+    const cachePromise = cacheExecute(input, route, silgiURL, event);
+    const beforeHookPromise = silgiCtx.callHook("fetch:before", {
+      url: silgiURL,
+      input,
+      event,
+      route
+    });
+    const cacheData = await cachePromise;
+    await beforeHookPromise;
     if (cacheData?.success) {
-      result = cacheData.data;
-      success = cacheData.success;
-      cached = cacheData.cached;
-    } else {
-      silgiCtx.shared.$fetch = silgiFetch;
-      silgiCtx.shared.silgi = silgiCtx;
-      result = await setup?.handler(
-        {
-          args: input,
-          parameters: {
-            query: queryParams,
-            path: routerParams
-          }
-        },
-        silgiCtx.shared,
+      await silgiCtx.callHook("fetch:after", {
         event,
-        event.context.source
-      );
-      success = true;
+        url: silgiURL,
+        input,
+        result: cacheData.data,
+        success: true,
+        // modules: setup.modules,
+        route
+      });
+      return cacheData.data;
     }
+    silgiCtx.shared.$fetch = silgiFetch;
+    silgiCtx.shared.silgi = silgiCtx;
+    const result = await setup?.handler(
+      {
+        args: input,
+        parameters: {
+          query: queryParams,
+          path: routerParams
+        }
+      },
+      silgiCtx.shared,
+      event,
+      event.context.source
+    );
     await silgiCtx.callHook("fetch:after", {
+      event,
       url: silgiURL,
       input,
       result,
-      success,
-      modules: setup.modules
+      success: true,
+      // modules: setup.modules,
+      route
     });
-    if (!cached) {
-      if (success && cacheData?.cachedKey && setup.storage) {
-        await useSilgiStorage(setup.storage.base).setItem(cacheData.cachedKey, result, setup.storage.options);
-      }
+    if (setup.storage && cacheData?.cachedKey) {
+      await useSilgiStorage(setup.storage.base).setItem(
+        cacheData.cachedKey,
+        result,
+        // Cast to StorageValue if needed
+        setup.storage.options
+      );
     }
     return result;
   } catch (err) {
     await silgiCtx.callHook("fetch:error", {
+      event,
       input,
       error: err instanceof Error ? err : new Error(String(err)),
-      url: silgiURL
+      url: silgiURL,
+      route
     });
     silgiCtx.captureError(
       silgiCtx,
@@ -869,17 +885,11 @@ function getEvent(event) {
   if (event?.event) {
     return getEvent(event.event);
   }
-  if (isRuntimePresents(["h3", "nitro", "nuxt"])) {
-    return event;
-  }
   return event;
 }
 function getEventContext(event) {
   const _event = getEvent(event);
-  if (isRuntimePresents(["h3", "nitro", "nuxt"])) {
-    return _event.context;
-  }
-  return _event;
+  return _event.context;
 }
 
 function createSchema(params) {

package/dist/index.mjs

@@ -10,4 +10,3 @@ import 'klona';
 import 'silgi/runtime';
 import 'unstorage';
 import 'srvx';
-import 'silgi/kit';

package/dist/runtime/internal/next.mjs

@@ -1,10 +1,9 @@
-import { createError, getUrlPrefix, isError, silgiFetch, useSilgi } from "silgi";
+import { createError, silgiFetch, useSilgi } from "silgi";
 export function toNextJsHandler(silgiContext = useSilgi()) {
   const handler = async (request) => {
     if (!silgiContext) {
       throw new Error("Silgi context is not defined");
     }
-    const silgiURL = getUrlPrefix(request.url, request.method);
     try {
       const res = await silgiFetch(request);
       if (!res.ok) {
@@ -22,30 +21,6 @@ export function toNextJsHandler(silgiContext = useSilgi()) {
       }
       return res;
     } catch (err) {
-      if (isError(err)) {
-        throw createError({
-          statusCode: 500,
-          statusMessage: "Internal Server Error",
-          cause: err
-        });
-      }
-      await silgiContext.callHook("fetch:error", {
-        error: err instanceof Error ? err : new Error(String(err)),
-        url: silgiURL
-      });
-      silgiContext.captureError(
-        silgiContext,
-        createError({
-          message: err instanceof Error ? err.message : String(err),
-          statusCode: 500,
-          statusMessage: "Internal Server Error",
-          cause: err
-        }),
-        {
-          url: silgiURL,
-          tags: ["execute"]
-        }
-      );
       throw createError({
         statusCode: 500,
         message: "Internal Server Error",

package/dist/runtime/internal/nitro.mjs

@@ -1,13 +1,10 @@
 import {
-  createError as createH3Error,
   defineEventHandler,
-  getRequestWebStream,
-  H3Error
+  getRequestWebStream
 } from "h3";
 import {
   createError,
   getUrlPrefix,
-  isError,
   silgiFetch,
   useSilgi
 } from "silgi";
@@ -53,34 +50,6 @@ export async function addNitroApp(silgiContext = useSilgi()) {
         }
         return resolvedRoute;
       } catch (err) {
-        if (err instanceof H3Error) {
-          throw err;
-        }
-        if (isError(err)) {
-          throw createH3Error({
-            statusCode: 500,
-            statusMessage: "Internal Server Error",
-            cause: err
-          });
-        }
-        await silgiContext.callHook("fetch:error", {
-          error: err instanceof Error ? err : new Error(String(err)),
-          url: silgiURL
-        });
-        silgiContext.captureError(
-          silgiContext,
-          createError({
-            message: err instanceof Error ? err.message : String(err),
-            statusCode: 500,
-            statusMessage: "Internal Server Error",
-            cause: err
-          }),
-          {
-            event,
-            url: silgiURL,
-            tags: ["execute"]
-          }
-        );
         throw createError({
           statusCode: 500,
           message: "Internal Server Error",