@kuratchi/js 0.0.15 → 0.0.17

package/dist/compiler/config-reading.js

@@ -0,0 +1,380 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function skipWhitespace(source, start) {
+    let i = start;
+    while (i < source.length && /\s/.test(source[i]))
+        i++;
+    return i;
+}
+function extractBalancedBody(source, start, openChar, closeChar) {
+    if (source[start] !== openChar)
+        return null;
+    let depth = 0;
+    for (let i = start; i < source.length; i++) {
+        if (source[i] === openChar)
+            depth++;
+        else if (source[i] === closeChar) {
+            depth--;
+            if (depth === 0)
+                return source.slice(start + 1, i);
+        }
+    }
+    return null;
+}
+function readConfigBlock(source, key) {
+    const keyRegex = new RegExp(`\\b${key}\\s*:`);
+    const keyMatch = keyRegex.exec(source);
+    if (!keyMatch)
+        return null;
+    const colonIdx = source.indexOf(':', keyMatch.index);
+    if (colonIdx === -1)
+        return null;
+    const valueIdx = skipWhitespace(source, colonIdx + 1);
+    if (valueIdx >= source.length)
+        return null;
+    if (source[valueIdx] === '{') {
+        throw new Error(`[kuratchi] "${key}" config must use an adapter call (e.g. ${key}: kuratchi${key[0].toUpperCase()}${key.slice(1)}Config({...})).`);
+    }
+    const callOpen = source.indexOf('(', valueIdx);
+    if (callOpen === -1)
+        return null;
+    const argIdx = skipWhitespace(source, callOpen + 1);
+    if (argIdx >= source.length)
+        return null;
+    if (source[argIdx] === ')')
+        return { kind: 'call-empty', body: '' };
+    if (source[argIdx] === '{') {
+        const body = extractBalancedBody(source, argIdx, '{', '}');
+        if (body == null)
+            return null;
+        return { kind: 'call-object', body };
+    }
+    return { kind: 'call-empty', body: '' };
+}
+export function readUiTheme(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const uiBlock = readConfigBlock(source, 'ui');
+    if (!uiBlock)
+        return null;
+    const themeMatch = uiBlock.body.match(/theme\s*:\s*['"]([^'"]+)['"]/);
+    const themeValue = themeMatch?.[1] ?? 'default';
+    if (themeValue === 'default' || themeValue === 'dark' || themeValue === 'light' || themeValue === 'system') {
+        const candidates = [
+            path.join(projectDir, 'node_modules', '@kuratchi/ui', 'src', 'styles', 'theme.css'),
+            path.join(path.resolve(projectDir, '../..'), 'packages', 'kuratchi-ui', 'src', 'styles', 'theme.css'),
+            path.join(path.resolve(projectDir, '../..'), 'node_modules', '@kuratchi/ui', 'src', 'styles', 'theme.css'),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return fs.readFileSync(candidate, 'utf-8');
+            }
+        }
+        console.warn(`[kuratchi] ui.theme: "${themeValue}" configured but @kuratchi/ui theme.css not found`);
+        return null;
+    }
+    const customPath = path.resolve(projectDir, themeValue);
+    if (fs.existsSync(customPath)) {
+        return fs.readFileSync(customPath, 'utf-8');
+    }
+    console.warn(`[kuratchi] ui.theme: "${themeValue}" not found at ${customPath}`);
+    return null;
+}
+export function readUiConfigValues(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const uiBlock = readConfigBlock(source, 'ui');
+    if (!uiBlock)
+        return null;
+    const themeMatch = uiBlock.body.match(/theme\s*:\s*['"]([^'"]+)['"]/);
+    const radiusMatch = uiBlock.body.match(/radius\s*:\s*['"]([^'"]+)['"]/);
+    return {
+        theme: themeMatch?.[1] ?? 'dark',
+        radius: radiusMatch?.[1] ?? 'default',
+    };
+}
+export function readOrmConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const ormBlock = readConfigBlock(source, 'orm');
+    if (!ormBlock)
+        return [];
+    const importMap = new Map();
+    const importRegex = /import\s*\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(source)) !== null) {
+        const names = match[1].split(',').map((name) => name.trim()).filter(Boolean);
+        const importPath = match[2];
+        for (const name of names) {
+            importMap.set(name, importPath);
+        }
+    }
+    const databasesIdx = ormBlock.body.search(/databases\s*:\s*\{/);
+    if (databasesIdx === -1)
+        return [];
+    const dbBraceStart = ormBlock.body.indexOf('{', databasesIdx);
+    if (dbBraceStart === -1)
+        return [];
+    const databasesBody = extractBalancedBody(ormBlock.body, dbBraceStart, '{', '}');
+    if (databasesBody == null)
+        return [];
+    const entries = [];
+    const entryRegex = /(\w+)\s*:\s*\{\s*schema\s*:\s*(\w+)([^}]*)\}/g;
+    while ((match = entryRegex.exec(databasesBody)) !== null) {
+        const binding = match[1];
+        const schemaExportName = match[2];
+        const rest = match[3] || '';
+        const skipMatch = rest.match(/skipMigrations\s*:\s*(true|false)/);
+        const skipMigrations = skipMatch?.[1] === 'true';
+        const typeMatch = rest.match(/type\s*:\s*['"]?(d1|do)['"]?/);
+        const type = typeMatch?.[1] ?? 'd1';
+        const schemaImportPath = importMap.get(schemaExportName);
+        if (!schemaImportPath)
+            continue;
+        entries.push({ binding, schemaImportPath, schemaExportName, skipMigrations, type });
+    }
+    return entries;
+}
+export function readAuthConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return null;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const authBlockMatch = readConfigBlock(source, 'auth');
+    if (!authBlockMatch)
+        return null;
+    const authBlock = authBlockMatch.body;
+    const cookieMatch = authBlock.match(/cookieName\s*:\s*['"]([^'"]+)['"]/);
+    const secretMatch = authBlock.match(/secretEnvKey\s*:\s*['"]([^'"]+)['"]/);
+    const sessionMatch = authBlock.match(/sessionEnabled\s*:\s*(true|false)/);
+    return {
+        cookieName: cookieMatch?.[1] ?? 'kuratchi_session',
+        secretEnvKey: secretMatch?.[1] ?? 'AUTH_SECRET',
+        sessionEnabled: sessionMatch?.[1] !== 'false',
+        hasCredentials: /credentials\s*:/.test(authBlock),
+        hasActivity: /activity\s*:/.test(authBlock),
+        hasRoles: /roles\s*:/.test(authBlock),
+        hasOAuth: /oauth\s*:/.test(authBlock),
+        hasGuards: /guards\s*:/.test(authBlock),
+        hasRateLimit: /rateLimit\s*:/.test(authBlock),
+        hasTurnstile: /turnstile\s*:/.test(authBlock),
+        hasOrganization: /organizations\s*:/.test(authBlock),
+    };
+}
+export function readDoConfig(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const doIdx = source.search(/durableObjects\s*:\s*\{/);
+    if (doIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', doIdx);
+    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 doBlock = source.slice(braceStart + 1, braceEnd);
+    const entries = [];
+    const objRegex = /(\w+)\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+    let match;
+    while ((match = objRegex.exec(doBlock)) !== null) {
+        const binding = match[1];
+        const body = match[2];
+        const cnMatch = body.match(/className\s*:\s*['"](\w+)['"]/);
+        if (!cnMatch)
+            continue;
+        const entry = { binding, className: cnMatch[1] };
+        const stubIdMatch = body.match(/stubId\s*:\s*['"]([^'"]+)['"]/);
+        if (stubIdMatch)
+            entry.stubId = stubIdMatch[1];
+        const filesMatch = body.match(/files\s*:\s*\[([\s\S]*?)\]/);
+        if (filesMatch) {
+            const list = [];
+            const itemRegex = /['"]([^'"]+)['"]/g;
+            let fileMatch;
+            while ((fileMatch = itemRegex.exec(filesMatch[1])) !== null) {
+                list.push(fileMatch[1]);
+            }
+            if (list.length > 0)
+                entry.files = list;
+        }
+        entries.push(entry);
+    }
+    const foundBindings = new Set(entries.map((entry) => entry.binding));
+    const pairRegex = /(\w+)\s*:\s*['"](\w+)['"]\s*[,}\n]/g;
+    while ((match = pairRegex.exec(doBlock)) !== null) {
+        if (foundBindings.has(match[1]))
+            continue;
+        if (['className', 'stubId'].includes(match[1]))
+            continue;
+        entries.push({ binding: match[1], className: match[2] });
+    }
+    return entries;
+}
+export function readWorkerClassConfig(projectDir, key) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return [];
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const keyIdx = source.search(new RegExp(`\\b${key}\\s*:\\s*\\{`));
+    if (keyIdx === -1)
+        return [];
+    const braceStart = source.indexOf('{', keyIdx);
+    if (braceStart === -1)
+        return [];
+    const body = extractBalancedBody(source, braceStart, '{', '}');
+    if (body == null)
+        return [];
+    const entries = [];
+    const expectedSuffix = key === 'containers' ? '.container' : '.workflow';
+    const allowedExt = /\.(ts|js|mjs|cjs)$/i;
+    const requiredFilePattern = new RegExp(`\\${expectedSuffix}\\.(ts|js|mjs|cjs)$`, 'i');
+    const resolveClassFromFile = (binding, filePath) => {
+        if (!requiredFilePattern.test(filePath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} must reference a file ending in "${expectedSuffix}.ts|js|mjs|cjs". Received: ${filePath}`);
+        }
+        if (!allowedExt.test(filePath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} file must be a TypeScript or JavaScript module. Received: ${filePath}`);
+        }
+        const absPath = path.isAbsolute(filePath) ? filePath : path.join(projectDir, filePath);
+        if (!fs.existsSync(absPath)) {
+            throw new Error(`[kuratchi] ${key}.${binding} file not found: ${filePath}`);
+        }
+        const fileSource = fs.readFileSync(absPath, 'utf-8');
+        const defaultClass = fileSource.match(/export\s+default\s+class\s+(\w+)/);
+        if (defaultClass) {
+            return { className: defaultClass[1], exportKind: 'default' };
+        }
+        const namedClass = fileSource.match(/export\s+class\s+(\w+)/);
+        if (namedClass) {
+            return { className: namedClass[1], exportKind: 'named' };
+        }
+        throw new Error(`[kuratchi] ${key}.${binding} must export a class via "export class X" or "export default class X". File: ${filePath}`);
+    };
+    const objRegex = /(\w+)\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+    let match;
+    while ((match = objRegex.exec(body)) !== null) {
+        const binding = match[1];
+        const entryBody = match[2];
+        const fileMatch = entryBody.match(/file\s*:\s*['"]([^'"]+)['"]/);
+        if (!fileMatch)
+            continue;
+        const inferred = resolveClassFromFile(binding, fileMatch[1]);
+        const classMatch = entryBody.match(/className\s*:\s*['"](\w+)['"]/);
+        const className = classMatch?.[1] ?? inferred.className;
+        entries.push({
+            binding,
+            className,
+            file: fileMatch[1],
+            exportKind: inferred.exportKind,
+        });
+    }
+    const foundBindings = new Set(entries.map((entry) => entry.binding));
+    const pairRegex = /(\w+)\s*:\s*['"]([^'"]+)['"]\s*[,}\n]/g;
+    while ((match = pairRegex.exec(body)) !== null) {
+        const binding = match[1];
+        const file = match[2];
+        if (foundBindings.has(binding))
+            continue;
+        if (binding === 'file' || binding === 'className')
+            continue;
+        const inferred = resolveClassFromFile(binding, file);
+        entries.push({
+            binding,
+            className: inferred.className,
+            file,
+            exportKind: inferred.exportKind,
+        });
+    }
+    return entries;
+}
+export function readAssetsPrefix(projectDir) {
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return '/assets/';
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const match = source.match(/assetsPrefix\s*:\s*['"]([^'"]+)['"]/);
+    if (!match)
+        return '/assets/';
+    let prefix = match[1];
+    if (!prefix.startsWith('/'))
+        prefix = '/' + prefix;
+    if (!prefix.endsWith('/'))
+        prefix += '/';
+    return prefix;
+}
+export function readSecurityConfig(projectDir) {
+    const defaults = {
+        csrfEnabled: true,
+        csrfCookieName: '__kuratchi_csrf',
+        csrfHeaderName: 'x-kuratchi-csrf',
+        rpcRequireAuth: false,
+        actionRequireAuth: false,
+        contentSecurityPolicy: null,
+        strictTransportSecurity: null,
+        permissionsPolicy: null,
+    };
+    const configPath = path.join(projectDir, 'kuratchi.config.ts');
+    if (!fs.existsSync(configPath))
+        return defaults;
+    const source = fs.readFileSync(configPath, 'utf-8');
+    const securityBlock = readConfigBlock(source, 'security');
+    if (!securityBlock)
+        return defaults;
+    const body = securityBlock.body;
+    // Parse CSRF settings
+    const csrfEnabledMatch = body.match(/csrfEnabled\s*:\s*(true|false)/);
+    if (csrfEnabledMatch) {
+        defaults.csrfEnabled = csrfEnabledMatch[1] === 'true';
+    }
+    const csrfCookieMatch = body.match(/csrfCookieName\s*:\s*['"]([^'"]+)['"]/);
+    if (csrfCookieMatch) {
+        defaults.csrfCookieName = csrfCookieMatch[1];
+    }
+    const csrfHeaderMatch = body.match(/csrfHeaderName\s*:\s*['"]([^'"]+)['"]/);
+    if (csrfHeaderMatch) {
+        defaults.csrfHeaderName = csrfHeaderMatch[1];
+    }
+    // Parse RPC settings
+    const rpcAuthMatch = body.match(/rpcRequireAuth\s*:\s*(true|false)/);
+    if (rpcAuthMatch) {
+        defaults.rpcRequireAuth = rpcAuthMatch[1] === 'true';
+    }
+    // Parse action settings
+    const actionAuthMatch = body.match(/actionRequireAuth\s*:\s*(true|false)/);
+    if (actionAuthMatch) {
+        defaults.actionRequireAuth = actionAuthMatch[1] === 'true';
+    }
+    // Parse security headers
+    const cspMatch = body.match(/contentSecurityPolicy\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (cspMatch) {
+        defaults.contentSecurityPolicy = cspMatch[1];
+    }
+    const hstsMatch = body.match(/strictTransportSecurity\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (hstsMatch) {
+        defaults.strictTransportSecurity = hstsMatch[1];
+    }
+    const permMatch = body.match(/permissionsPolicy\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (permMatch) {
+        defaults.permissionsPolicy = permMatch[1];
+    }
+    return defaults;
+}

package/dist/compiler/convention-discovery.d.ts

@@ -0,0 +1,9 @@
+import { type ConventionClassEntry, type WorkerClassConfigEntry } from './compiler-shared.js';
+export declare function resolveClassExportFromFile(absPath: string, errorLabel: string): {
+    className: string;
+    exportKind: 'named' | 'default';
+};
+export declare function discoverConventionClassFiles(projectDir: string, dir: string, suffix: string, errorLabel: string): ConventionClassEntry[];
+export declare function discoverFilesWithSuffix(dir: string, suffix: string): string[];
+export declare function discoverWorkflowFiles(projectDir: string): WorkerClassConfigEntry[];
+export declare function discoverContainerFiles(projectDir: string): WorkerClassConfigEntry[];

package/dist/compiler/convention-discovery.js

@@ -0,0 +1,83 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function resolveClassExportFromFile(absPath, errorLabel) {
+    if (!fs.existsSync(absPath)) {
+        throw new Error(`[kuratchi] ${errorLabel} file not found: ${absPath}`);
+    }
+    const fileSource = fs.readFileSync(absPath, 'utf-8');
+    const defaultClass = fileSource.match(/export\s+default\s+class\s+(\w+)/);
+    if (defaultClass) {
+        return { className: defaultClass[1], exportKind: 'default' };
+    }
+    const namedClass = fileSource.match(/export\s+class\s+(\w+)/);
+    if (namedClass) {
+        return { className: namedClass[1], exportKind: 'named' };
+    }
+    throw new Error(`[kuratchi] ${errorLabel} must export a class via "export class X" or "export default class X". File: ${absPath}`);
+}
+export function discoverConventionClassFiles(projectDir, dir, suffix, errorLabel) {
+    const absDir = path.join(projectDir, dir);
+    const files = discoverFilesWithSuffix(absDir, suffix);
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const resolved = resolveClassExportFromFile(absPath, errorLabel);
+        return {
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}
+export function discoverFilesWithSuffix(dir, suffix) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const walk = (absDir) => {
+        for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
+            const abs = path.join(absDir, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs);
+            }
+            else if (entry.isFile() && abs.endsWith(suffix)) {
+                out.push(abs);
+            }
+        }
+    };
+    walk(dir);
+    return out;
+}
+export function discoverWorkflowFiles(projectDir) {
+    const serverDir = path.join(projectDir, 'src', 'server');
+    const files = discoverFilesWithSuffix(serverDir, '.workflow.ts');
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const fileName = path.basename(absPath, '.workflow.ts');
+        const binding = fileName.toUpperCase().replace(/-/g, '_') + '_WORKFLOW';
+        const resolved = resolveClassExportFromFile(absPath, '.workflow');
+        return {
+            binding,
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}
+export function discoverContainerFiles(projectDir) {
+    const serverDir = path.join(projectDir, 'src', 'server');
+    const files = discoverFilesWithSuffix(serverDir, '.container.ts');
+    if (files.length === 0)
+        return [];
+    return files.map((absPath) => {
+        const fileName = path.basename(absPath, '.container.ts');
+        const binding = fileName.toUpperCase().replace(/-/g, '_') + '_CONTAINER';
+        const resolved = resolveClassExportFromFile(absPath, '.container');
+        return {
+            binding,
+            className: resolved.className,
+            file: path.relative(projectDir, absPath).replace(/\\/g, '/'),
+            exportKind: resolved.exportKind,
+        };
+    });
+}

package/dist/compiler/durable-object-pipeline.d.ts

@@ -0,0 +1,9 @@
+import { type DoConfigEntry, type DoHandlerEntry, type OrmDatabaseEntry } from './compiler-shared.js';
+export declare function discoverDurableObjects(srcDir: string, configDoEntries: DoConfigEntry[], ormDatabases: OrmDatabaseEntry[]): {
+    config: DoConfigEntry[];
+    handlers: DoHandlerEntry[];
+};
+export declare function generateHandlerProxy(handler: DoHandlerEntry, opts: {
+    projectDir: string;
+    runtimeDoImport: string;
+}): string;