@kuratchi/js 0.0.15 → 0.0.17

package/dist/compiler/durable-object-pipeline.js

@@ -0,0 +1,255 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { toSafeIdentifier, } from './compiler-shared.js';
+import { discoverFilesWithSuffix } from './convention-discovery.js';
+export function discoverDurableObjects(srcDir, configDoEntries, ormDatabases) {
+    const serverDir = path.join(srcDir, 'server');
+    const legacyDir = path.join(srcDir, 'durable-objects');
+    const serverDoFiles = discoverFilesWithSuffix(serverDir, '.do.ts');
+    const legacyDoFiles = discoverFilesWithSuffix(legacyDir, '.ts');
+    const discoveredFiles = Array.from(new Set([...serverDoFiles, ...legacyDoFiles]));
+    if (discoveredFiles.length === 0) {
+        return { config: configDoEntries, handlers: [] };
+    }
+    const configByBinding = new Map();
+    for (const entry of configDoEntries) {
+        configByBinding.set(entry.binding, entry);
+    }
+    const handlers = [];
+    const discoveredConfig = [];
+    const fileNameToAbsPath = new Map();
+    const seenBindings = new Set();
+    for (const absPath of discoveredFiles) {
+        const file = path.basename(absPath);
+        const source = fs.readFileSync(absPath, 'utf-8');
+        if (!/extends\s+DurableObject\b/.test(source))
+            continue;
+        const classMatch = source.match(/export\s+default\s+class\s+(\w+)\s+extends\s+DurableObject/);
+        const className = classMatch?.[1] ?? null;
+        if (!className)
+            continue;
+        const bindingMatch = source.match(/static\s+binding\s*=\s*['"](\w+)['"]/);
+        const baseName = file.replace(/\.do\.ts$/, '').replace(/\.ts$/, '');
+        const derivedBinding = baseName.replace(/([a-z])([A-Z])/g, '$1_$2').toUpperCase() + '_DO';
+        const binding = bindingMatch?.[1] ?? derivedBinding;
+        if (seenBindings.has(binding)) {
+            throw new Error(`[KuratchiJS] Duplicate DO binding '${binding}' detected. Use 'static binding = "UNIQUE_NAME"' in one of the classes.`);
+        }
+        seenBindings.add(binding);
+        const classMethods = extractClassMethods(source, className);
+        const fileName = file.replace(/\.ts$/, '');
+        const existing = fileNameToAbsPath.get(fileName);
+        if (existing && existing !== absPath) {
+            throw new Error(`[KuratchiJS] Duplicate DO handler file name '${fileName}.ts' detected:\n- ${existing}\n- ${absPath}\nRename one file or move it to avoid proxy name collision.`);
+        }
+        fileNameToAbsPath.set(fileName, absPath);
+        const configEntry = configByBinding.get(binding);
+        void ormDatabases;
+        discoveredConfig.push({
+            binding,
+            className,
+            stubId: configEntry?.stubId,
+            files: [file],
+        });
+        handlers.push({
+            fileName,
+            absPath,
+            binding,
+            mode: 'class',
+            className,
+            classMethods,
+            exportedFunctions: [],
+        });
+    }
+    return { config: discoveredConfig, handlers };
+}
+export function generateHandlerProxy(handler, opts) {
+    const doDir = path.join(opts.projectDir, '.kuratchi', 'do');
+    const origRelPath = path.relative(doDir, handler.absPath).replace(/\\/g, '/');
+    const handlerLocal = `__handler_${toSafeIdentifier(handler.fileName)}`;
+    const lifecycle = new Set(['constructor', 'fetch', 'alarm', 'webSocketMessage', 'webSocketClose', 'webSocketError']);
+    const rpcFunctions = handler.classMethods
+        .filter((method) => method.visibility === 'public' && !method.name.startsWith('_') && !lifecycle.has(method.name))
+        .map((method) => method.name);
+    const methods = handler.classMethods.map((method) => ({ ...method }));
+    const methodMap = new Map(methods.map((method) => [method.name, method]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const method of methods) {
+            if (method.hasWorkerContextCalls)
+                continue;
+            for (const called of method.callsThisMethods) {
+                const target = methodMap.get(called);
+                if (target?.hasWorkerContextCalls) {
+                    method.hasWorkerContextCalls = true;
+                    changed = true;
+                    break;
+                }
+            }
+        }
+    }
+    const workerContextMethods = methods
+        .filter((method) => method.visibility === 'public' && method.hasWorkerContextCalls)
+        .map((method) => method.name);
+    const asyncMethods = methods.filter((method) => method.isAsync).map((method) => method.name);
+    const lines = [
+        `// Auto-generated by KuratchiJS compiler �" do not edit.`,
+        `import { __getDoStub } from '${opts.runtimeDoImport}';`,
+        `import ${handlerLocal} from '${origRelPath}';`,
+        ``,
+        `const __FD_TAG = '__kuratchi_form_data__';`,
+        `function __isPlainObject(__v) {`,
+        `  if (!__v || typeof __v !== 'object') return false;`,
+        `  const __proto = Object.getPrototypeOf(__v);`,
+        `  return __proto === Object.prototype || __proto === null;`,
+        `}`,
+        `function __encodeArg(__v, __seen = new WeakSet()) {`,
+        `  if (typeof FormData !== 'undefined' && __v instanceof FormData) {`,
+        `    return { [__FD_TAG]: Array.from(__v.entries()) };`,
+        `  }`,
+        `  if (Array.isArray(__v)) return __v.map((__x) => __encodeArg(__x, __seen));`,
+        `  if (__isPlainObject(__v)) {`,
+        `    if (__seen.has(__v)) throw new Error('[KuratchiJS] Circular object passed to DO RPC');`,
+        `    __seen.add(__v);`,
+        `    const __out = {};`,
+        `    for (const [__k, __val] of Object.entries(__v)) __out[__k] = __encodeArg(__val, __seen);`,
+        `    __seen.delete(__v);`,
+        `    return __out;`,
+        `  }`,
+        `  return __v;`,
+        `}`,
+        `function __decodeArg(__v) {`,
+        `  if (Array.isArray(__v)) return __v.map(__decodeArg);`,
+        `  if (__isPlainObject(__v)) {`,
+        `    const __obj = __v;`,
+        `    if (__FD_TAG in __obj) {`,
+        `      const __fd = new FormData();`,
+        `      const __entries = Array.isArray(__obj[__FD_TAG]) ? __obj[__FD_TAG] : [];`,
+        `      for (const __pair of __entries) {`,
+        `        if (Array.isArray(__pair) && __pair.length >= 2) __fd.append(String(__pair[0]), __pair[1]);`,
+        `      }`,
+        `      return __fd;`,
+        `    }`,
+        `    const __out = {};`,
+        `    for (const [__k, __val] of Object.entries(__obj)) __out[__k] = __decodeArg(__val);`,
+        `    return __out;`,
+        `  }`,
+        `  return __v;`,
+        `}`,
+        ``,
+    ];
+    if (workerContextMethods.length > 0) {
+        lines.push(`const __workerMethods = new Set(${JSON.stringify(workerContextMethods)});`);
+        lines.push(`const __asyncMethods = new Set(${JSON.stringify(asyncMethods)});`);
+        lines.push(`function __callWorkerMethod(__name, __args) {`);
+        lines.push(`  const __self = new Proxy({}, {`);
+        lines.push(`    get(_, __k) {`);
+        lines.push(`      if (typeof __k !== 'string') return undefined;`);
+        lines.push(`      if (__k === 'db') {`);
+        lines.push(`        throw new Error("[KuratchiJS] Worker-executed DO method cannot use this.db directly. Move DB access into a non-public method and call it via this.<method>().");`);
+        lines.push(`      }`);
+        lines.push(`      if (__workerMethods.has(__k)) {`);
+        lines.push(`        return (...__a) => ${handlerLocal}.prototype[__k].apply(__self, __a);`);
+        lines.push(`      }`);
+        lines.push(`      const __local = ${handlerLocal}.prototype[__k];`);
+        lines.push(`      if (typeof __local === 'function' && !__asyncMethods.has(__k)) {`);
+        lines.push(`        return (...__a) => __local.apply(__self, __a);`);
+        lines.push(`      }`);
+        lines.push(`      return async (...__a) => { const __s = await __getDoStub('${handler.binding}'); if (!__s) throw new Error('Not authenticated'); return __s[__k](...__a.map((__x) => __encodeArg(__x))); };`);
+        lines.push(`    },`);
+        lines.push(`  });`);
+        lines.push(`  return ${handlerLocal}.prototype[__name].apply(__self, __args.map(__decodeArg));`);
+        lines.push(`}`);
+        lines.push(``);
+    }
+    for (const method of rpcFunctions) {
+        if (workerContextMethods.includes(method)) {
+            lines.push(`export async function ${method}(...a) { return __callWorkerMethod('${method}', a); }`);
+        }
+        else {
+            lines.push(`export async function ${method}(...a) { const s = await __getDoStub('${handler.binding}'); if (!s) throw new Error('Not authenticated'); return s.${method}(...a.map((__x) => __encodeArg(__x))); }`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+function extractClassMethods(source, className) {
+    const classIdx = source.search(new RegExp(`class\\s+${className}\\s+extends\\s+DurableObject`));
+    if (classIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', classIdx);
+    if (braceStart === -1)
+        return [];
+    let depth = 0;
+    let braceEnd = braceStart;
+    for (let i = braceStart; i < source.length; i++) {
+        if (source[i] === '{')
+            depth++;
+        else if (source[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                braceEnd = i;
+                break;
+            }
+        }
+    }
+    const classBody = source.slice(braceStart + 1, braceEnd);
+    const methods = [];
+    const methodRegex = /^\s+(?:(public|private|protected)\s+)?(?:(static)\s+)?(?:(async)\s+)?([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*(?::[^{]+)?\{/gm;
+    const reserved = new Set([
+        'constructor', 'static', 'get', 'set',
+        'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case',
+        'throw', 'try', 'catch', 'finally', 'new', 'delete', 'typeof',
+        'void', 'instanceof', 'in', 'of', 'await', 'yield', 'const',
+        'let', 'var', 'function', 'class', 'import', 'export', 'default',
+        'break', 'continue', 'with', 'super', 'this',
+    ]);
+    let match;
+    while ((match = methodRegex.exec(classBody)) !== null) {
+        const visibility = match[1] ?? 'public';
+        const isStatic = !!match[2];
+        const isAsync = !!match[3];
+        const name = match[4];
+        if (!name || isStatic || reserved.has(name))
+            continue;
+        const matchText = match[0] ?? '';
+        const openRel = matchText.lastIndexOf('{');
+        const openAbs = openRel >= 0 ? match.index + openRel : -1;
+        let hasWorkerContextCalls = false;
+        const callsThisMethods = [];
+        if (openAbs >= 0) {
+            let innerDepth = 0;
+            let endAbs = openAbs;
+            for (let i = openAbs; i < classBody.length; i++) {
+                const ch = classBody[i];
+                if (ch === '{')
+                    innerDepth++;
+                else if (ch === '}') {
+                    innerDepth--;
+                    if (innerDepth === 0) {
+                        endAbs = i;
+                        break;
+                    }
+                }
+            }
+            const bodySource = classBody.slice(openAbs + 1, endAbs);
+            hasWorkerContextCalls = /\b(getCurrentUser|redirect|goto|getRequest|getLocals)\s*\(/.test(bodySource);
+            const called = new Set();
+            const callRegex = /\bthis\.([A-Za-z_$][\w$]*)\s*\(/g;
+            let callMatch;
+            while ((callMatch = callRegex.exec(bodySource)) !== null) {
+                called.add(callMatch[1]);
+            }
+            callsThisMethods.push(...called);
+        }
+        methods.push({
+            name,
+            visibility: visibility,
+            isStatic,
+            isAsync,
+            hasWorkerContextCalls,
+            callsThisMethods,
+        });
+    }
+    return methods;
+}

package/dist/compiler/error-page-pipeline.d.ts

@@ -0,0 +1 @@
+export declare function compileErrorPages(routesDir: string): Map<number, string>;

package/dist/compiler/error-page-pipeline.js

@@ -0,0 +1,16 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { compileTemplate } from './template.js';
+export function compileErrorPages(routesDir) {
+    const compiledErrorPages = new Map();
+    for (const file of fs.readdirSync(routesDir)) {
+        const match = file.match(/^(\d{3})\.html$/);
+        if (!match)
+            continue;
+        const status = parseInt(match[1], 10);
+        const source = fs.readFileSync(path.join(routesDir, file), 'utf-8');
+        const body = compileTemplate(source);
+        compiledErrorPages.set(status, `function __error_${status}(error) {\n  ${body}\n  return __html;\n}`);
+    }
+    return compiledErrorPages;
+}

package/dist/compiler/import-linking.d.ts

@@ -0,0 +1,36 @@
+export interface ImportBinding {
+    imported: string;
+    local: string;
+}
+export interface ParsedImportStatement {
+    bindings: ImportBinding[];
+    moduleSpecifier: string | null;
+    namespaceImport: string | null;
+}
+export interface RouteImportEntry {
+    line: string;
+    importerDir: string;
+}
+interface RouteQueryReference {
+    fnName: string;
+}
+export declare function parseImportStatement(source: string): ParsedImportStatement;
+export declare function collectReferencedIdentifiers(source: string): Set<string>;
+export declare function parseNamedImportBindings(line: string): ImportBinding[];
+export declare function filterImportsByNeededBindings(imports: string[], neededBindings: Set<string>): string[];
+export declare function linkRouteServerImports(opts: {
+    routeServerImportEntries: RouteImportEntry[];
+    routeClientImportEntries: RouteImportEntry[];
+    actionFunctions: string[];
+    pollFunctions: string[];
+    dataGetQueries: RouteQueryReference[];
+    routeScriptReferenceSource: string;
+    resolveCompiledImportPath: (origPath: string, importerDir: string, outFileDir: string) => string;
+    outFileDir: string;
+    allocateModuleId: () => string;
+}): {
+    fnToModule: Record<string, string>;
+    routeImportDecls: string[];
+    importStatements: string[];
+};
+export {};

package/dist/compiler/import-linking.js

@@ -0,0 +1,140 @@
+import ts from 'typescript';
+export function parseImportStatement(source) {
+    const sourceFile = ts.createSourceFile('kuratchi-import.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const statement = sourceFile.statements.find(ts.isImportDeclaration);
+    if (!statement || !ts.isStringLiteral(statement.moduleSpecifier)) {
+        return { bindings: [], moduleSpecifier: null, namespaceImport: null };
+    }
+    const bindings = [];
+    let namespaceImport = null;
+    const clause = statement.importClause;
+    if (clause) {
+        if (clause.name) {
+            bindings.push({ imported: 'default', local: clause.name.text });
+        }
+        if (clause.namedBindings) {
+            if (ts.isNamedImports(clause.namedBindings)) {
+                for (const element of clause.namedBindings.elements) {
+                    bindings.push({
+                        imported: element.propertyName?.text || element.name.text,
+                        local: element.name.text,
+                    });
+                }
+            }
+            else if (ts.isNamespaceImport(clause.namedBindings)) {
+                namespaceImport = clause.namedBindings.name.text;
+            }
+        }
+    }
+    return {
+        bindings,
+        moduleSpecifier: statement.moduleSpecifier.text,
+        namespaceImport,
+    };
+}
+function isTypePosition(node) {
+    for (let current = node; current; current = current.parent) {
+        if (ts.isTypeNode(current))
+            return true;
+    }
+    return false;
+}
+function isReferenceIdentifier(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (isTypePosition(node))
+        return false;
+    if (ts.isImportClause(parent) || ts.isImportSpecifier(parent) || ts.isNamespaceImport(parent) || ts.isNamedImports(parent))
+        return false;
+    if (ts.isExportSpecifier(parent))
+        return false;
+    if (ts.isBindingElement(parent) || ts.isParameter(parent) || ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || ts.isClassDeclaration(parent)) {
+        return parent.name !== node;
+    }
+    if (ts.isPropertyAssignment(parent) && parent.name === node)
+        return false;
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node)
+        return true;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+        return false;
+    if (ts.isQualifiedName(parent) && parent.right === node)
+        return false;
+    if (ts.isPropertyDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent)) {
+        return parent.name !== node;
+    }
+    if (ts.isLabeledStatement(parent) || ts.isBreakStatement(parent) || ts.isContinueStatement(parent))
+        return false;
+    return true;
+}
+export function collectReferencedIdentifiers(source) {
+    const refs = new Set();
+    const sourceFile = ts.createSourceFile('kuratchi-ref.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && isReferenceIdentifier(node)) {
+            refs.add(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return refs;
+}
+export function parseNamedImportBindings(line) {
+    return parseImportStatement(line).bindings.filter((binding) => binding.imported !== 'default');
+}
+export function filterImportsByNeededBindings(imports, neededBindings) {
+    const selected = [];
+    for (const line of imports) {
+        const parsed = parseImportStatement(line);
+        const hasNeededBinding = parsed.bindings.some((binding) => neededBindings.has(binding.local))
+            || (parsed.namespaceImport ? neededBindings.has(parsed.namespaceImport) : false);
+        if (hasNeededBinding)
+            selected.push(line);
+    }
+    return selected;
+}
+const RESERVED_RENDER_VARS = new Set(['params', 'breadcrumbs']);
+export function linkRouteServerImports(opts) {
+    const fnToModule = {};
+    const routeImportDeclMap = new Map();
+    const importStatements = [];
+    const neededServerFns = new Set([
+        ...opts.actionFunctions,
+        ...opts.pollFunctions,
+        ...opts.dataGetQueries.map((query) => query.fnName),
+    ]);
+    const routeServerImports = opts.routeServerImportEntries.length > 0
+        ? opts.routeServerImportEntries
+        : opts.routeClientImportEntries.filter((entry) => (filterImportsByNeededBindings([entry.line], neededServerFns).length > 0));
+    for (const entry of routeServerImports) {
+        const parsed = parseImportStatement(entry.line);
+        if (!parsed.moduleSpecifier)
+            continue;
+        const isWorkerEnvModule = parsed.moduleSpecifier === 'cloudflare:workers';
+        const isKuratchiEnvModule = parsed.moduleSpecifier === '@kuratchi/js/environment';
+        const importPath = opts.resolveCompiledImportPath(parsed.moduleSpecifier, entry.importerDir, opts.outFileDir);
+        const moduleId = opts.allocateModuleId();
+        importStatements.push(`import * as ${moduleId} from '${importPath}';`);
+        for (const binding of parsed.bindings) {
+            if ((isWorkerEnvModule && binding.imported === 'env') || (isKuratchiEnvModule && binding.imported === 'dev')) {
+                continue;
+            }
+            fnToModule[binding.local] = moduleId;
+            if (!routeImportDeclMap.has(binding.local) && !RESERVED_RENDER_VARS.has(binding.local)) {
+                const accessExpr = binding.imported === 'default' ? `${moduleId}.default` : `${moduleId}.${binding.imported}`;
+                routeImportDeclMap.set(binding.local, `const ${binding.local} = ${accessExpr};`);
+            }
+        }
+        if (parsed.namespaceImport) {
+            fnToModule[parsed.namespaceImport] = moduleId;
+            if (!routeImportDeclMap.has(parsed.namespaceImport)) {
+                routeImportDeclMap.set(parsed.namespaceImport, `const ${parsed.namespaceImport} = ${moduleId};`);
+            }
+        }
+    }
+    return {
+        fnToModule,
+        routeImportDecls: Array.from(routeImportDeclMap.values()),
+        importStatements,
+    };
+}

package/dist/compiler/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Compiler �" scans a project's routes/ directory, parses .html files,
+ * Compiler ?" scans a project's routes/ directory, parses .html files,
  * and generates a single Worker entry point.
  */
 export { parseFile } from './parser.js';
@@ -7,7 +7,7 @@ export { compileTemplate, generateRenderFunction } from './template.js';
 export interface CompileOptions {
     /** Absolute path to the project root */
     projectDir: string;
-    /** Override path for routes.js (default: .kuratchi/routes.js). worker.js is always co-located. */
+    /** Override path for routes.ts (default: .kuratchi/routes.ts). worker.ts is always co-located. */
     outFile?: string;
     /** Whether this is a dev build (sets __kuratchi_DEV__ global) */
     isDev?: boolean;
@@ -25,12 +25,12 @@ export interface CompiledRoute {
     hasRpc: boolean;
 }
 /**
- * Compile a project's src/routes/ into .kuratchi/routes.js
+ * Compile a project's src/routes/ into .kuratchi/routes.ts
  *
- * The generated module exports { app } �" an object with a fetch() method
+ * The generated module exports { app } — an object with a fetch() method
  * that handles routing, load functions, form actions, and rendering.
- * Returns the path to .kuratchi/worker.js � the stable wrangler entry point that
- * re-exports everything from routes.js (default fetch handler + named DO class exports).
+ * Returns the path to .kuratchi/worker.ts — the stable wrangler entry point that
+ * re-exports everything from routes.ts (default fetch handler + named DO class exports).
  * No src/index.ts is needed in user projects.
  */
-export declare function compile(options: CompileOptions): string;
+export declare function compile(options: CompileOptions): Promise<string>;