@openpkg-ts/extract 0.12.0 → 0.14.0

package/dist/src/index.js

@@ -1,78 +1,383 @@
 import {
+  BUILTIN_TYPE_SCHEMAS,
   TypeRegistry,
   buildSchema,
   createProgram,
+  deduplicateSchemas,
   extract,
   extractParameters,
+  extractTypeParameters,
+  findDiscriminatorProperty,
   getJSDocComment,
+  getParamDescription,
   getSourceLocation,
   isAnonymous,
   isBuiltinGeneric,
   isPrimitiveName,
+  isPureRefSchema,
+  isSymbolDeprecated,
   registerReferencedTypes,
+  schemaIsAny,
+  schemasAreEqual,
   serializeClass,
   serializeEnum,
   serializeFunctionExport,
   serializeInterface,
   serializeTypeAlias,
-  serializeVariable
-} from "../shared/chunk-wddga8ye.js";
+  serializeVariable,
+  withDescription
+} from "../shared/chunk-v4cnenxs.js";
+// src/schema/registry.ts
+function isTypeReference(type) {
+  return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
+}
+function getNonNullableType(type) {
+  if (type.isUnion()) {
+    const nonNullable = type.types.filter((t) => !(t.flags & 32768) && !(t.flags & 65536));
+    if (nonNullable.length === 1) {
+      return nonNullable[0];
+    }
+  }
+  return type;
+}
+var adapters = [];
+function registerAdapter(adapter) {
+  adapters.push(adapter);
+}
+function findAdapter(type, checker) {
+  return adapters.find((a) => a.matches(type, checker));
+}
+function isSchemaType(type, checker) {
+  return adapters.some((a) => a.matches(type, checker));
+}
+function extractSchemaType(type, checker) {
+  const adapter = findAdapter(type, checker);
+  if (!adapter)
+    return null;
+  const outputType = adapter.extractOutputType(type, checker);
+  if (!outputType)
+    return null;
+  const inputType = adapter.extractInputType?.(type, checker);
+  return {
+    adapter,
+    outputType,
+    inputType
+  };
+}
+
 // src/schema/adapters/arktype.ts
+var ARKTYPE_TYPE_PATTERN = /^Type</;
 var arktypeAdapter = {
-  name: "arktype",
-  detect: () => false,
-  extract: () => null
+  id: "arktype",
+  packages: ["arktype"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return ARKTYPE_TYPE_PATTERN.test(typeName);
+  },
+  extractOutputType(type, checker) {
+    if (!isTypeReference(type)) {
+      return null;
+    }
+    const args = checker.getTypeArguments(type);
+    if (args.length < 1) {
+      return null;
+    }
+    return args[0];
+  },
+  extractInputType(type, checker) {
+    if (!isTypeReference(type)) {
+      return null;
+    }
+    const args = checker.getTypeArguments(type);
+    if (args.length < 2) {
+      return null;
+    }
+    return args[1];
+  }
 };
+
 // src/schema/adapters/typebox.ts
+var TYPEBOX_TYPE_PATTERN = /^T[A-Z]/;
 var typeboxAdapter = {
-  name: "typebox",
-  detect: () => false,
-  extract: () => null
+  id: "typebox",
+  packages: ["@sinclair/typebox"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    if (!TYPEBOX_TYPE_PATTERN.test(typeName)) {
+      return false;
+    }
+    const typeProperty = type.getProperty("type");
+    return typeProperty !== undefined;
+  },
+  extractOutputType(type, checker) {
+    const staticSymbol = type.getProperty("static");
+    if (staticSymbol) {
+      return checker.getTypeOfSymbol(staticSymbol);
+    }
+    return null;
+  }
 };
+
 // src/schema/adapters/valibot.ts
+var VALIBOT_TYPE_PATTERN = /Schema(<|$)/;
 var valibotAdapter = {
-  name: "valibot",
-  detect: () => false,
-  extract: () => null
+  id: "valibot",
+  packages: ["valibot"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return VALIBOT_TYPE_PATTERN.test(typeName) && !typeName.includes("Zod");
+  },
+  extractOutputType(type, checker) {
+    const typesSymbol = type.getProperty("~types");
+    if (!typesSymbol) {
+      return null;
+    }
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const outputSymbol = typesType.getProperty("output");
+    if (!outputSymbol) {
+      return null;
+    }
+    return checker.getTypeOfSymbol(outputSymbol);
+  },
+  extractInputType(type, checker) {
+    const typesSymbol = type.getProperty("~types");
+    if (!typesSymbol) {
+      return null;
+    }
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const inputSymbol = typesType.getProperty("input");
+    if (!inputSymbol) {
+      return null;
+    }
+    return checker.getTypeOfSymbol(inputSymbol);
+  }
 };
+
 // src/schema/adapters/zod.ts
+var ZOD_TYPE_PATTERN = /^Zod[A-Z]/;
 var zodAdapter = {
-  name: "zod",
-  detect: () => false,
-  extract: () => null
+  id: "zod",
+  packages: ["zod"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return ZOD_TYPE_PATTERN.test(typeName);
+  },
+  extractOutputType(type, checker) {
+    const outputSymbol = type.getProperty("_output");
+    if (outputSymbol) {
+      return checker.getTypeOfSymbol(outputSymbol);
+    }
+    const typeSymbol = type.getProperty("_type");
+    if (typeSymbol) {
+      return checker.getTypeOfSymbol(typeSymbol);
+    }
+    return null;
+  },
+  extractInputType(type, checker) {
+    const inputSymbol = type.getProperty("_input");
+    if (inputSymbol) {
+      return checker.getTypeOfSymbol(inputSymbol);
+    }
+    return null;
+  }
 };
-// src/schema/registry.ts
-var adapters = [];
-function registerAdapter(adapter) {
-  adapters.push(adapter);
+
+// src/schema/adapters/index.ts
+registerAdapter(zodAdapter);
+registerAdapter(valibotAdapter);
+registerAdapter(arktypeAdapter);
+registerAdapter(typeboxAdapter);
+// src/schema/standard-schema.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isStandardJSONSchema(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const std = obj["~standard"];
+  if (typeof std !== "object" || std === null)
+    return false;
+  const stdObj = std;
+  if (typeof stdObj.version !== "number")
+    return false;
+  if (typeof stdObj.vendor !== "string")
+    return false;
+  const jsonSchema = stdObj.jsonSchema;
+  if (typeof jsonSchema !== "object" || jsonSchema === null)
+    return false;
+  const jsObj = jsonSchema;
+  return typeof jsObj.output === "function";
 }
-function findAdapter(node, checker) {
-  return adapters.find((a) => a.detect(node, checker));
+var WORKER_SCRIPT = `
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+// TypeBox detection: schemas have Symbol.for('TypeBox.Kind') and are JSON Schema
+const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
+
+function isTypeBoxSchema(obj) {
+  if (!obj || typeof obj !== 'object') return false;
+  // TypeBox schemas always have Kind symbol (Union, Object, String, etc.)
+  // Also check for common JSON Schema props to avoid false positives
+  if (!obj[TYPEBOX_KIND]) return false;
+  return typeof obj.type === 'string' || 'anyOf' in obj || 'oneOf' in obj || 'allOf' in obj;
 }
-function isSchemaType(node, checker) {
-  return adapters.some((a) => a.detect(node, checker));
+
+function sanitizeTypeBoxSchema(schema) {
+  // JSON.stringify removes symbol keys, keeping only JSON Schema props
+  return JSON.parse(JSON.stringify(schema));
 }
-function extractSchemaType(node, checker) {
-  const adapter = findAdapter(node, checker);
-  return adapter?.extract(node, checker) ?? null;
+
+async function extract() {
+  // With node -e, argv is: [node, arg1, arg2, ...]
+  // (the -e script is NOT in argv)
+  const [modulePath, target] = process.argv.slice(1);
+
+  try {
+    // Import the module using dynamic import (works with ESM and CJS)
+    const absPath = path.resolve(modulePath);
+    const mod = await import(pathToFileURL(absPath).href);
+    const results = [];
+
+    // Build exports map - handle both ESM and CJS (where exports are in mod.default)
+    const exports = {};
+    for (const [name, value] of Object.entries(mod)) {
+      if (name === 'default' && typeof value === 'object' && value !== null) {
+        // CJS module: spread default exports
+        Object.assign(exports, value);
+      } else if (name !== 'default') {
+        exports[name] = value;
+      }
+    }
+
+    // Check each export
+    for (const [name, value] of Object.entries(exports)) {
+      if (name.startsWith('_')) continue;
+      if (typeof value !== 'object' || value === null) continue;
+
+      // Priority 1: Standard Schema (Zod 4.2+, ArkType, etc.)
+      const std = value['~standard'];
+      if (std && typeof std === 'object' && typeof std.version === 'number' && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
+        try {
+          const outputSchema = std.jsonSchema.output(target);
+          const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
+          results.push({
+            exportName: name,
+            vendor: std.vendor,
+            outputSchema,
+            inputSchema
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+
+      // Priority 2: TypeBox (schema IS JSON Schema)
+      if (isTypeBoxSchema(value)) {
+        try {
+          results.push({
+            exportName: name,
+            vendor: 'typebox',
+            outputSchema: sanitizeTypeBoxSchema(value)
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+    }
+
+    console.log(JSON.stringify({ success: true, results }));
+  } catch (e) {
+    console.log(JSON.stringify({ success: false, error: e.message }));
+  }
 }
-// src/schema/standard-schema.ts
-function extractStandardSchemas(_program, _entryFile) {
-  return [];
+
+extract();
+`;
+function resolveCompiledPath(tsPath, baseDir) {
+  const relativePath = path.relative(baseDir, tsPath);
+  const withoutExt = relativePath.replace(/\.tsx?$/, "");
+  const candidates = [
+    path.join(baseDir, `${withoutExt}.js`),
+    path.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
+    path.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
+    path.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
 }
-// src/types/formatter.ts
-function formatTypeReference(type, checker) {
-  return checker.typeToString(type);
+async function extractStandardSchemas(compiledJsPath, options = {}) {
+  const { timeout = 1e4, target = "draft-2020-12" } = options;
+  const result = {
+    schemas: new Map,
+    errors: []
+  };
+  if (!fs.existsSync(compiledJsPath)) {
+    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
+    return result;
+  }
+  return new Promise((resolve) => {
+    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, target], {
+      timeout,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
+        resolve(result);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        if (!parsed.success) {
+          result.errors.push(`Extraction failed: ${parsed.error}`);
+          resolve(result);
+          return;
+        }
+        for (const item of parsed.results) {
+          result.schemas.set(item.exportName, {
+            exportName: item.exportName,
+            vendor: item.vendor,
+            outputSchema: item.outputSchema,
+            inputSchema: item.inputSchema
+          });
+        }
+      } catch (e) {
+        result.errors.push(`Failed to parse extraction output: ${e}`);
+      }
+      resolve(result);
+    });
+    child.on("error", (err) => {
+      result.errors.push(`Subprocess error: ${err.message}`);
+      resolve(result);
+    });
+  });
 }
-function collectReferencedTypes(type, checker, visited = new Set) {
-  const symbol = type.getSymbol();
-  if (!symbol)
-    return [];
-  const name = symbol.getName();
-  if (visited.has(name))
-    return [];
-  visited.add(name);
-  return [name];
+async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
+    };
+  }
+  return extractStandardSchemas(compiledPath, options);
 }
 // src/types/utils.ts
 function isExported(node) {
@@ -90,6 +395,7 @@ function getNodeName(node) {
 }
 export {
   zodAdapter,
+  withDescription,
   valibotAdapter,
   typeboxAdapter,
   serializeVariable,
@@ -98,25 +404,37 @@ export {
   serializeFunctionExport,
   serializeEnum,
   serializeClass,
+  schemasAreEqual,
+  schemaIsAny,
+  resolveCompiledPath,
   registerReferencedTypes,
   registerAdapter,
+  isTypeReference,
+  isSymbolDeprecated,
+  isStandardJSONSchema,
   isSchemaType,
+  isPureRefSchema,
   isPrimitiveName,
   isExported,
   isBuiltinGeneric,
   isAnonymous,
   getSourceLocation,
+  getParamDescription,
+  getNonNullableType,
   getNodeName,
   getJSDocComment,
-  formatTypeReference,
+  findDiscriminatorProperty,
   findAdapter,
+  extractTypeParameters,
+  extractStandardSchemasFromProject,
   extractStandardSchemas,
   extractSchemaType,
   extractParameters,
   extract,
+  deduplicateSchemas,
   createProgram,
-  collectReferencedTypes,
   buildSchema,
   arktypeAdapter,
-  TypeRegistry
+  TypeRegistry,
+  BUILTIN_TYPE_SCHEMAS
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",
@@ -42,6 +42,7 @@
   "dependencies": {
     "@openpkg-ts/spec": "^0.12.0",
     "commander": "^12.0.0",
+    "tree-sitter-wasms": "^0.1.13",
     "typescript": "^5.0.0"
   },
   "devDependencies": {