cloesce 0.0.3-fix.1 → 0.0.3-fix.2

package/dist/{cli.js → extractor/cli.js}

@@ -6,77 +6,178 @@ import { fileURLToPath } from "node:url";
 import { command, run, subcommands, flag, option, optional, string, } from "cmd-ts";
 import { Project } from "ts-morph";
 import { CidlExtractor } from "./extract.js";
-import { ExtractorError, ExtractorErrorCode, getErrorInfo } from "./common.js";
+import { ExtractorError, ExtractorErrorCode, getErrorInfo } from "../common.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const WASM_PATH = path.join(__dirname, "cli.wasm");
-function loadCloesceConfig(root, debug = false) {
-    const configPath = path.join(root, "cloesce-config.json");
-    if (fs.existsSync(configPath)) {
-        try {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            if (debug)
-                console.log(`Loaded config from ${configPath}`);
-            return config;
-        }
-        catch (err) {
-            console.warn(`Failed to parse cloesce-config.json: ${err}`);
-        }
-    }
-    return {};
-}
-function readPackageJsonProjectName(cwd) {
-    const pkgPath = path.join(cwd, "package.json");
-    let projectName = path.basename(cwd);
-    if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        projectName = pkg.name ?? projectName;
-    }
-    return projectName;
-}
-function findCloesceProject(root, searchPaths, project) {
-    for (const searchPath of searchPaths) {
-        let fullPath;
-        if (path.isAbsolute(searchPath) || searchPath.startsWith(root)) {
-            fullPath = path.normalize(searchPath);
-        }
-        else {
-            fullPath = path.resolve(root, searchPath);
-        }
-        if (!fs.existsSync(fullPath)) {
-            console.warn(`Warning: Path "${searchPath}" does not exist`);
-            continue;
-        }
-        const stats = fs.statSync(fullPath);
-        if (stats.isFile() && /\.cloesce\.ts$/i.test(fullPath)) {
-            project.addSourceFileAtPath(fullPath);
-        }
-        else if (stats.isDirectory()) {
-            walkDirectory(fullPath, project);
-        }
-    }
-    function walkDirectory(dir, project) {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory() && !entry.name.startsWith(".")) {
-                walkDirectory(fullPath, project);
-            }
-            else if (entry.isFile() && /\.cloesce\.ts$/i.test(entry.name)) {
-                project.addSourceFileAtPath(fullPath);
-            }
-        }
-    }
-}
-function formatErr(e) {
-    const { description, suggestion } = getErrorInfo(e.code);
-    const contextLine = e.context ? `Context: ${e.context}\n` : "";
-    const snippetLine = e.snippet ? `${e.snippet}\n\n` : "";
-    return `==== CLOESCE ERROR ====
-Error [${ExtractorErrorCode[e.code]}]: ${description}
-Phase: TypeScript IDL Extraction
-${contextLine}${snippetLine}Suggested fix: ${suggestion}`;
-}
-async function runExtractor(opts) {
+const GENERATOR_WASM_PATH = path.join(__dirname, "cli.wasm");
+const cmds = subcommands({
+    name: "cloesce",
+    cmds: {
+        compile: command({
+            name: "compile",
+            description: "Run through the full compilation process.",
+            args: {
+                debug: flag({
+                    long: "debug",
+                    short: "d",
+                    description: "Show debug output",
+                }),
+            },
+            handler: async (args) => {
+                const config = loadCloesceConfig(process.cwd(), args.debug);
+                if (!config.workersUrl || !config.clientUrl) {
+                    console.error("Error: `workersUrl` and `clientUrl` must be defined in cloesce.config.json");
+                    process.exit(1);
+                }
+                // Creates a `cidl.json` file. Exits the process on failure.
+                await extract({ debug: args.debug });
+                const root = process.cwd();
+                const outputDir = config.outputDir ?? ".generated";
+                const allConfig = {
+                    name: "all",
+                    wasmFile: "generator.wasm",
+                    args: [
+                        "generate",
+                        "all",
+                        path.join(outputDir, "cidl.json"),
+                        path.join(root, "wrangler.toml"),
+                        path.join(outputDir, "migrations.sql"),
+                        path.join(outputDir, "workers.ts"),
+                        path.join(outputDir, "client.ts"),
+                        config.clientUrl,
+                        config.workersUrl,
+                    ],
+                };
+                // Runs a generator command. Exits the process on failure.
+                await generate(allConfig);
+            },
+        }),
+        wrangler: command({
+            name: "wrangler",
+            description: "Generate wrangler.toml configuration",
+            args: {},
+            handler: async () => {
+                const root = process.cwd();
+                await generate({
+                    name: "wrangler",
+                    wasmFile: "generator.wasm",
+                    args: ["generate", "wrangler", path.join(root, "wrangler.toml")],
+                });
+            },
+        }),
+        d1: command({
+            name: "d1",
+            description: "Generate database schema",
+            args: {},
+            handler: async () => {
+                const config = loadCloesceConfig(process.cwd());
+                const outputDir = config.outputDir ?? ".generated";
+                await generate({
+                    name: "d1",
+                    wasmFile: "generator.wasm",
+                    args: [
+                        "generate",
+                        "d1",
+                        path.join(outputDir, "cidl.json"),
+                        path.join(outputDir, "migrations.sql"),
+                    ],
+                });
+            },
+        }),
+        workers: command({
+            name: "workers",
+            description: "Generate workers TypeScript",
+            args: {},
+            handler: async () => {
+                const config = loadCloesceConfig(process.cwd());
+                const root = process.cwd();
+                const outputDir = config.outputDir ?? ".generated";
+                if (!config.workersUrl) {
+                    console.error("Error: workersUrl must be defined in cloesce-config.json");
+                    process.exit(1);
+                }
+                await generate({
+                    name: "workers",
+                    wasmFile: "generator.wasm",
+                    args: [
+                        "generate",
+                        "workers",
+                        path.join(outputDir, "cidl.json"),
+                        path.join(outputDir, "workers.ts"),
+                        path.join(root, "wrangler.toml"),
+                        config.workersUrl,
+                    ],
+                });
+            },
+        }),
+        client: command({
+            name: "client",
+            description: "Generate client TypeScript",
+            args: {},
+            handler: async () => {
+                const config = loadCloesceConfig(process.cwd());
+                const outputDir = config.outputDir ?? ".generated";
+                if (!config.clientUrl) {
+                    console.error("Error: clientUrl must be defined in cloesce-config.json");
+                    process.exit(1);
+                }
+                await generate({
+                    name: "client",
+                    wasmFile: "generator.wasm",
+                    args: [
+                        "generate",
+                        "client",
+                        path.join(outputDir, "cidl.json"),
+                        path.join(outputDir, "client.ts"),
+                        config.clientUrl,
+                    ],
+                });
+            },
+        }),
+        extract: command({
+            name: "extract",
+            description: "Extract models and write cidl.json only",
+            args: {
+                projectName: option({
+                    long: "project-name",
+                    type: optional(string),
+                    description: "Project name",
+                }),
+                out: option({
+                    long: "out",
+                    short: "o",
+                    type: optional(string),
+                    description: "Output path (default: .generated/cidl.json)",
+                }),
+                inp: option({
+                    long: "in",
+                    short: "i",
+                    type: optional(string),
+                    description: "Input file or directory",
+                }),
+                location: option({
+                    long: "location",
+                    short: "l",
+                    type: optional(string),
+                    description: "Project directory (default: cwd)",
+                }),
+                truncateSourcePaths: flag({
+                    long: "truncateSourcePaths",
+                    description: "Sets all source paths to just their file name",
+                }),
+                debug: flag({
+                    long: "debug",
+                    short: "d",
+                    description: "Show debug output",
+                }),
+            },
+            handler: async (args) => {
+                await extract({ ...args });
+            },
+        }),
+    },
+});
+async function extract(opts) {
     const root = process.cwd();
     const projectRoot = process.cwd();
     const config = loadCloesceConfig(projectRoot, opts.debug);
@@ -132,7 +233,7 @@ async function runExtractor(opts) {
         process.exit(1);
     }
 }
-async function runWasmCommand(config) {
+async function generate(config) {
     const root = process.cwd();
     // Look for wrangler.toml in the root directory
     const wranglerPath = path.join(root, "wrangler.toml");
@@ -158,11 +259,11 @@ async function runWasmCommand(config) {
     });
     const wasi = new WASI({
         version: "preview1",
-        args: [path.basename(WASM_PATH), ...wasiArgs],
+        args: [path.basename(GENERATOR_WASM_PATH), ...wasiArgs],
         env: { ...process.env, ...config.env },
         preopens: { "/": root },
     });
-    const bytes = fs.readFileSync(WASM_PATH);
+    const bytes = fs.readFileSync(GENERATOR_WASM_PATH);
     const mod = await WebAssembly.compile(bytes);
     const instance = await WebAssembly.instantiate(mod, {
         wasi_snapshot_preview1: wasi.wasiImport,
@@ -174,179 +275,73 @@ async function runWasmCommand(config) {
         console.error(`WASM execution failed for ${config.name}:`, err);
     }
 }
-const runCmd = command({
-    name: "run",
-    description: "Extract CIDL and run all code generators",
-    args: {
-        debug: flag({
-            long: "debug",
-            short: "d",
-            description: "Show debug output",
-        }),
-    },
-    handler: async (args) => {
-        const config = loadCloesceConfig(process.cwd(), args.debug);
-        if (!config.workersUrl || !config.clientUrl) {
-            console.error("Error: workersUrl and clientUrl must be defined in cloesce-config.json");
-            process.exit(1);
+function loadCloesceConfig(root, debug = false) {
+    const configPath = path.join(root, "cloesce.config.json");
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            if (debug)
+                console.log(`Loaded config from ${configPath}`);
+            return config;
         }
-        await runExtractor({ debug: args.debug });
-        const root = process.cwd();
-        const outputDir = config.outputDir ?? ".generated";
-        const allConfig = {
-            name: "all",
-            wasmFile: "cli.wasm",
-            args: [
-                "generate",
-                "all",
-                path.join(outputDir, "cidl.json"),
-                path.join(root, "wrangler.toml"),
-                path.join(outputDir, "migrations.sql"),
-                path.join(outputDir, "workers.ts"),
-                path.join(outputDir, "client.ts"),
-                config.clientUrl,
-                config.workersUrl,
-            ],
-        };
-        await runWasmCommand(allConfig);
-    },
-});
-// In case the user wants to run individual steps we should probably allow them
-const wranglerCmd = command({
-    name: "wrangler",
-    description: "Generate wrangler.toml configuration",
-    args: {},
-    handler: async () => {
-        const root = process.cwd();
-        await runWasmCommand({
-            name: "wrangler",
-            wasmFile: "cli.wasm",
-            args: ["generate", "wrangler", path.join(root, "wrangler.toml")],
-        });
-    },
-});
-const d1Cmd = command({
-    name: "d1",
-    description: "Generate database schema",
-    args: {},
-    handler: async () => {
-        const config = loadCloesceConfig(process.cwd());
-        const outputDir = config.outputDir ?? ".generated";
-        await runWasmCommand({
-            name: "d1",
-            wasmFile: "cli.wasm",
-            args: [
-                "generate",
-                "d1",
-                path.join(outputDir, "cidl.json"),
-                path.join(outputDir, "migrations.sql"),
-            ],
-        });
-    },
-});
-const workersCmd = command({
-    name: "workers",
-    description: "Generate workers TypeScript",
-    args: {},
-    handler: async () => {
-        const config = loadCloesceConfig(process.cwd());
-        const root = process.cwd();
-        const outputDir = config.outputDir ?? ".generated";
-        if (!config.workersUrl) {
-            console.error("Error: workersUrl must be defined in cloesce-config.json");
-            process.exit(1);
+        catch (err) {
+            console.warn(`Failed to parse cloesce.config.json: ${err}`);
         }
-        await runWasmCommand({
-            name: "workers",
-            wasmFile: "cli.wasm",
-            args: [
-                "generate",
-                "workers",
-                path.join(outputDir, "cidl.json"),
-                path.join(outputDir, "workers.ts"),
-                path.join(root, "wrangler.toml"),
-                config.workersUrl,
-            ],
-        });
-    },
-});
-const clientCmd = command({
-    name: "client",
-    description: "Generate client TypeScript",
-    args: {},
-    handler: async () => {
-        const config = loadCloesceConfig(process.cwd());
-        const outputDir = config.outputDir ?? ".generated";
-        if (!config.clientUrl) {
-            console.error("Error: clientUrl must be defined in cloesce-config.json");
-            process.exit(1);
+    }
+    return {};
+}
+function readPackageJsonProjectName(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    let projectName = path.basename(cwd);
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        projectName = pkg.name ?? projectName;
+    }
+    return projectName;
+}
+function findCloesceProject(root, searchPaths, project) {
+    for (const searchPath of searchPaths) {
+        let fullPath;
+        if (path.isAbsolute(searchPath) || searchPath.startsWith(root)) {
+            fullPath = path.normalize(searchPath);
         }
-        await runWasmCommand({
-            name: "client",
-            wasmFile: "cli.wasm",
-            args: [
-                "generate",
-                "client",
-                path.join(outputDir, "cidl.json"),
-                path.join(outputDir, "client.ts"),
-                config.clientUrl,
-            ],
-        });
-    },
-});
-const extractCmd = command({
-    name: "extract",
-    description: "Extract models and write cidl.json only",
-    args: {
-        projectName: option({
-            long: "project-name",
-            type: optional(string),
-            description: "Project name",
-        }),
-        out: option({
-            long: "out",
-            short: "o",
-            type: optional(string),
-            description: "Output path (default: .generated/cidl.json)",
-        }),
-        inp: option({
-            long: "in",
-            short: "i",
-            type: optional(string),
-            description: "Input file or directory",
-        }),
-        location: option({
-            long: "location",
-            short: "l",
-            type: optional(string),
-            description: "Project directory (default: cwd)",
-        }),
-        truncateSourcePaths: flag({
-            long: "truncateSourcePaths",
-            description: "Sets all source paths to just their file name",
-        }),
-        debug: flag({
-            long: "debug",
-            short: "d",
-            description: "Show debug output",
-        }),
-    },
-    handler: async (args) => {
-        await runExtractor({ ...args });
-    },
-});
-const router = subcommands({
-    name: "cloesce",
-    cmds: {
-        run: runCmd,
-        extract: extractCmd,
-        wrangler: wranglerCmd,
-        d1: d1Cmd,
-        workers: workersCmd,
-        client: clientCmd,
-    },
-});
-run(router, process.argv.slice(2)).catch((err) => {
+        else {
+            fullPath = path.resolve(root, searchPath);
+        }
+        if (!fs.existsSync(fullPath)) {
+            console.warn(`Warning: Path "${searchPath}" does not exist`);
+            continue;
+        }
+        const stats = fs.statSync(fullPath);
+        if (stats.isFile() && /\.cloesce\.ts$/i.test(fullPath)) {
+            project.addSourceFileAtPath(fullPath);
+        }
+        else if (stats.isDirectory()) {
+            walkDirectory(fullPath, project);
+        }
+    }
+    function walkDirectory(dir, project) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                walkDirectory(fullPath, project);
+            }
+            else if (entry.isFile() && /\.cloesce\.ts$/i.test(entry.name)) {
+                project.addSourceFileAtPath(fullPath);
+            }
+        }
+    }
+}
+function formatErr(e) {
+    const { description, suggestion } = getErrorInfo(e.code);
+    const contextLine = e.context ? `Context: ${e.context}\n` : "";
+    const snippetLine = e.snippet ? `${e.snippet}\n\n` : "";
+    return `==== CLOESCE ERROR ====
+Error [${ExtractorErrorCode[e.code]}]: ${description}
+Phase: TypeScript IDL Extraction
+${contextLine}${snippetLine}Suggested fix: ${suggestion}`;
+}
+run(cmds, process.argv.slice(2)).catch((err) => {
     console.error(err);
     process.exit(1);
 });

package/dist/{extract.js → extractor/extract.js}

@@ -1,5 +1,5 @@
 import { SyntaxKind, } from "ts-morph";
-import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, } from "./common.js";
+import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, } from "../common.js";
 import { TypeFormatFlags } from "typescript";
 var AttributeDecoratorKind;
 (function (AttributeDecoratorKind) {

package/dist/index.js

@@ -1,4 +1,4 @@
-export { cloesce, modelsFromSql } from "./cloesce.js";
+export { cloesce, modelsFromSql } from "./runtime/runtime.js";
 // Compiler hints
 export const D1 = () => { };
 export const PlainOldObject = () => { };