silgi 0.36.18 → 0.37.0

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.0";
 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.36.18",
+  "version": "0.37.0",
   "private": false,
   "sideEffects": false,
   "exports": {
@@ -117,6 +117,7 @@
     "mlly": "^1.7.4",
     "ofetch": "^1.4.1",
     "ohash": "^2.0.11",
+    "oxc-parser": "^0.68.1",
     "pathe": "^2.0.3",
     "perfect-debounce": "^1.0.0",
     "picocolors": "^1.1.1",