rastack 0.0.16

package/dist/rad-compile.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * `rad compile | check | list | urls` — the TypeScript-first replacement for the
+ * old Django `manage.py rastack` command.
+ *
+ *   rad compile [resourcesDir] [outDir]   defs → schema.rad.json + openapi.json
+ *   rad check   [resourcesDir]            validate the resource graph (exit != 0 on error)
+ *   rad list    [resourcesDir]            print every resource + its fields/relations
+ *   rad urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("./compile");
+const DEFAULT_RESOURCES = "resources";
+const DEFAULT_OUT = ".rad";
+function main(argv) {
+    const [sub, ...rest] = argv;
+    switch (sub) {
+        case "compile": {
+            const resourcesDir = rest[0] || DEFAULT_RESOURCES;
+            const outDir = rest[1] || DEFAULT_OUT;
+            const result = (0, compile_1.compile)(resourcesDir, outDir);
+            console.log(`✓ compiled ${result.manifest.resources.length} resource(s) → ${result.files.join(", ")}`);
+            break;
+        }
+        case "check": {
+            const resources = (0, compile_1.analyzeResources)(rest[0] || DEFAULT_RESOURCES);
+            const errors = (0, compile_1.collisions)(resources);
+            if (errors.length) {
+                for (const e of errors)
+                    console.error(`  ✗ ${e}`);
+                console.error(`${errors.length} error(s) found.`);
+                process.exit(1);
+            }
+            console.log(`✓ ${resources.length} resource(s): no collisions.`);
+            break;
+        }
+        case "list": {
+            const resources = (0, compile_1.analyzeResources)(rest[0] || DEFAULT_RESOURCES);
+            if (!resources.length) {
+                console.log("No resources found.");
+                break;
+            }
+            for (const r of resources) {
+                console.log(`${r.app}.${r.model}`);
+                for (const f of r.fields) {
+                    const rel = f.relation ? ` → ${f.relation.app}.${f.relation.model}` : "";
+                    console.log(`  ${f.name}: ${f.type}${rel}`);
+                }
+                if (r.sync) {
+                    const flags = [
+                        r.sync.mode,
+                        r.sync.load === "lazy" ? "lazy" : "",
+                        r.sync.clientIds ? "client-ids" : "",
+                        r.sync.confirmed ? `confirmed: ${r.sync.confirmed.join(",")}` : "",
+                    ]
+                        .filter(Boolean)
+                        .join(", ");
+                    console.log(`  sync: ${flags}`);
+                }
+            }
+            break;
+        }
+        case "urls": {
+            const resources = (0, compile_1.analyzeResources)(rest[0] || DEFAULT_RESOURCES);
+            for (const url of (0, compile_1.urlsFor)(resources))
+                console.log(url);
+            break;
+        }
+        default:
+            console.error(`Unknown compile subcommand: "${sub}"\n\n` +
+                `Usage:\n` +
+                `  rad compile [resourcesDir] [outDir]\n` +
+                `  rad check   [resourcesDir]\n` +
+                `  rad list    [resourcesDir]\n` +
+                `  rad urls    [resourcesDir]\n`);
+            process.exit(1);
+    }
+}
+if (require.main === module) {
+    main(process.argv.slice(2));
+}

package/dist/rad-wasm-build.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * `rad wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ *
+ * Pipeline:
+ *   1. cargo build -p rad-wasm --release --target wasm32-unknown-unknown
+ *   2. wasm-bindgen --target web  → stack/wasm/rad_wasm.js + rad_wasm_bg.wasm
+ *   3. wasm-opt -Oz (if available) to shrink the binary
+ *
+ * The generated bundle is what `<RadProvider mode="local">` loads. Prereqs:
+ *   rustup target add wasm32-unknown-unknown
+ *   cargo install wasm-bindgen-cli   (version must match the wasm-bindgen crate)
+ */
+export {};

package/dist/rad-wasm-build.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * `rad wasm` — compile the Rust API to WebAssembly for in-browser local dev.
+ *
+ * Pipeline:
+ *   1. cargo build -p rad-wasm --release --target wasm32-unknown-unknown
+ *   2. wasm-bindgen --target web  → stack/wasm/rad_wasm.js + rad_wasm_bg.wasm
+ *   3. wasm-opt -Oz (if available) to shrink the binary
+ *
+ * The generated bundle is what `<RadProvider mode="local">` loads. Prereqs:
+ *   rustup target add wasm32-unknown-unknown
+ *   cargo install wasm-bindgen-cli   (version must match the wasm-bindgen crate)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const repoRoot = path_1.default.resolve(__dirname, "..", "..");
+const rustDir = path_1.default.join(repoRoot, "rust");
+const outDir = path_1.default.join(repoRoot, "stack", "wasm");
+const wasmPath = path_1.default.join(rustDir, "target", "wasm32-unknown-unknown", "release", "rad_wasm.wasm");
+function run(cmd, args, cwd = repoRoot) {
+    var _a;
+    const result = (0, child_process_1.spawnSync)(cmd, args, { stdio: "inherit", cwd, env: process.env });
+    if (result.error) {
+        console.error(`\nCould not run \`${cmd}\`. Is it installed and on PATH?`);
+        if (cmd === "wasm-bindgen") {
+            console.error("  cargo install wasm-bindgen-cli");
+        }
+        process.exit(1);
+    }
+    if (result.status !== 0) {
+        process.exit((_a = result.status) !== null && _a !== void 0 ? _a : 1);
+    }
+}
+function has(cmd) {
+    return (0, child_process_1.spawnSync)(cmd, ["--version"], { stdio: "ignore" }).status === 0;
+}
+console.log("→ cargo build -p rad-wasm --release (wasm32-unknown-unknown)");
+run("cargo", [
+    "build",
+    "-p",
+    "rad-wasm",
+    "--release",
+    "--target",
+    "wasm32-unknown-unknown",
+], rustDir);
+console.log("→ wasm-bindgen → stack/wasm/");
+run("wasm-bindgen", [
+    "--target",
+    "web",
+    "--out-dir",
+    outDir,
+    "--out-name",
+    "rad_wasm",
+    wasmPath,
+]);
+// Mark the emitted bundle as ESM so Node and bundlers treat it correctly
+// without forcing the parent rad-stack package to be a module.
+fs_1.default.writeFileSync(path_1.default.join(outDir, "package.json"), JSON.stringify({ type: "module", sideEffects: false }, null, 2) + "\n");
+if (has("wasm-opt")) {
+    console.log("→ wasm-opt -Oz");
+    const bg = path_1.default.join(outDir, "rad_wasm_bg.wasm");
+    run("wasm-opt", ["-Oz", "-o", bg, bg]);
+}
+else {
+    console.log("· wasm-opt not found — skipping size optimisation (optional)");
+}
+const size = fs_1.default.statSync(path_1.default.join(outDir, "rad_wasm_bg.wasm")).size;
+console.log(`✓ wasm engine built: stack/wasm/ (${(size / 1024).toFixed(0)} KB)`);

package/dist/rad.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * rad — unified CLI for React API Stack
+ *
+ * Commands:
+ *   rad compile [resourcesDir] [outDir]     TypeScript resources → schema.rad.json + openapi.json
+ *   rad check   [resourcesDir]              Validate the resource graph
+ *   rad list    [resourcesDir]              Print resources, fields and relations
+ *   rad urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
+ *   rad generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rad serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rad admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
+ *   rad wasm                                Compile the API to WebAssembly (in-browser local dev)
+ *   rad scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
+ *   rad seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
+ */
+export {};

package/dist/rad.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * rad — unified CLI for React API Stack
+ *
+ * Commands:
+ *   rad compile [resourcesDir] [outDir]     TypeScript resources → schema.rad.json + openapi.json
+ *   rad check   [resourcesDir]              Validate the resource graph
+ *   rad list    [resourcesDir]              Print resources, fields and relations
+ *   rad urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
+ *   rad generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rad serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
+ *   rad admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
+ *   rad wasm                                Compile the API to WebAssembly (in-browser local dev)
+ *   rad scan   [files...] [--fail-on-pii]   Scan CSVs for PII and schema info
+ *   rad seed   [--env dev] [--source gs://] Load CSVs into Iceberg namespace
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const [command, ...rest] = process.argv.slice(2);
+function run(script, args = rest) {
+    (0, child_process_1.execSync)(`node ${path_1.default.join(__dirname, script)} ${args.join(" ")}`, {
+        stdio: "inherit",
+        env: process.env,
+    });
+}
+/** Invoke the compiled Rust server binary (built by `cargo build` in rust/). */
+function runRust(subcommand) {
+    var _a;
+    const repoRoot = path_1.default.resolve(__dirname, "..", "..");
+    const binary = process.env.RAD_SERVER_BIN ||
+        path_1.default.join(repoRoot, "rust", "target", "release", "rad-server");
+    const result = (0, child_process_1.spawnSync)(binary, [subcommand, ...rest], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    if (result.error) {
+        console.error(`Could not run the Rust server (${binary}). Build it first:\n` +
+            `  cd rust && cargo build --release\n`);
+        process.exit(1);
+    }
+    process.exit((_a = result.status) !== null && _a !== void 0 ? _a : 0);
+}
+switch (command) {
+    case "compile":
+    case "check":
+    case "list":
+    case "urls":
+        // rad-compile dispatches on its own first argument, so pass the command.
+        run("rad-compile.js", [command, ...rest]);
+        break;
+    case "serve":
+        runRust("serve");
+        break;
+    case "admin":
+        runRust("admin");
+        break;
+    case "wasm":
+        // Compile the API to WebAssembly for in-browser local dev.
+        run("rad-wasm-build.js", rest);
+        break;
+    case "scan":
+        run("scan.js");
+        break;
+    case "seed":
+        run("seed.js");
+        break;
+    case "generate":
+    case "gen":
+        // Proxy to existing rastack codegen pipeline
+        run("index.js");
+        break;
+    default:
+        console.error(`Unknown command: "${command}"\n\n` +
+            `Usage:\n` +
+            `  rad compile [resourcesDir] [outDir]\n` +
+            `  rad check | list | urls [resourcesDir]\n` +
+            `  rad generate [--schema-only]\n` +
+            `  rad serve | admin [--warehouse dir]\n` +
+            `  rad wasm                                Compile the API to WebAssembly (browser local dev)\n` +
+            `  rad scan   [files...] [--fail-on-pii]\n` +
+            `  rad seed   [--env dev|staging] [--source gs://bucket/ | ./myapp-dev/]\n`);
+        process.exit(1);
+}

package/dist/scan.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * rad scan
+ *
+ * Scans CSV files in myapp-dev/ for PII column patterns and schema issues.
+ * Exits non-zero if violations are found and --fail-on-pii is passed.
+ *
+ * Usage:
+ *   rad scan [files...] [--fail-on-pii]
+ *   rad scan myapp-dev/passengers.csv myapp-dev/flights.csv --fail-on-pii
+ */
+export {};

package/dist/scan.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * rad scan
+ *
+ * Scans CSV files in myapp-dev/ for PII column patterns and schema issues.
+ * Exits non-zero if violations are found and --fail-on-pii is passed.
+ *
+ * Usage:
+ *   rad scan [files...] [--fail-on-pii]
+ *   rad scan myapp-dev/passengers.csv myapp-dev/flights.csv --fail-on-pii
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const csv_schema_1 = require("./csv-schema");
+const args = process.argv.slice(2);
+const failOnPii = args.includes("--fail-on-pii");
+const fileArgs = args.filter((a) => !a.startsWith("--") && a.endsWith(".csv"));
+const repoRoot = process.cwd();
+const devDir = path_1.default.join(repoRoot, "myapp-dev");
+const files = fileArgs.length > 0 ? fileArgs : (0, csv_schema_1.discoverCsvFiles)(devDir);
+if (files.length === 0) {
+    console.log("No CSV files found to scan.");
+    process.exit(0);
+}
+let totalViolations = 0;
+let hasErrors = false;
+for (const csvPath of files) {
+    const rel = path_1.default.relative(repoRoot, csvPath);
+    let result;
+    try {
+        result = (0, csv_schema_1.inferSchema)(csvPath, repoRoot);
+    }
+    catch (err) {
+        console.error(`ERROR  ${rel}: ${err.message}`);
+        hasErrors = true;
+        continue;
+    }
+    const { schema, piiViolations } = result;
+    const colSummary = schema.columns
+        .map((c) => {
+        const tags = [c.type];
+        if (c.primaryKey)
+            tags.push("PK");
+        if (c.nullable)
+            tags.push("nullable");
+        if (c.pii)
+            tags.push("PII");
+        return `  ${c.name.padEnd(24)} ${tags.join(", ")}`;
+    })
+        .join("\n");
+    console.log(`\n${rel}  [${schema.rowCount} rows, fingerprint: ${schema.fingerprint}]`);
+    console.log(colSummary);
+    if (piiViolations.length > 0) {
+        totalViolations += piiViolations.length;
+        console.log(`\n  ⚠  PII violations (${piiViolations.length}):`);
+        for (const v of piiViolations) {
+            console.log(`     ${v.column}: ${v.reason}`);
+        }
+    }
+}
+console.log("");
+if (hasErrors) {
+    console.error("Scan completed with errors.");
+    process.exit(1);
+}
+if (totalViolations > 0) {
+    console.warn(`Scan found ${totalViolations} PII violation(s) across ${files.length} file(s).`);
+    if (failOnPii) {
+        console.error("Failing because --fail-on-pii is set. Remove PII data or add access policies in .rad/policies/.");
+        process.exit(1);
+    }
+}
+else {
+    console.log(`Scan passed. ${files.length} file(s) checked, no PII violations.`);
+}

package/dist/schema/camel-to-pastel.d.ts

@@ -0,0 +1 @@
+export declare function camelToPastel(str: string): string;

package/dist/schema/camel-to-pastel.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToPastel = void 0;
+function camelToPastel(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.camelToPastel = camelToPastel;

package/dist/schema/capitalise-first-letter.d.ts

@@ -0,0 +1 @@
+export declare function capitaliseFirstLetter(str: string): string;

package/dist/schema/capitalise-first-letter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitaliseFirstLetter = void 0;
+function capitaliseFirstLetter(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.capitaliseFirstLetter = capitaliseFirstLetter;

package/dist/schema/extract-response.d.ts

@@ -0,0 +1,2 @@
+import { OperationObject } from "@ts-stack/openapi-spec";
+export declare function extractResponseBodySchema(methodInformation: OperationObject): [string | undefined, boolean];

package/dist/schema/extract-response.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResponseBodySchema = void 0;
+function extractResponseBodySchema(methodInformation) {
+    let responseBodySchema;
+    let isList = false;
+    if (!methodInformation.responses)
+        return [undefined, false];
+    Object.keys(methodInformation.responses).forEach((responseKey) => {
+        // @ts-ignore
+        const responseData = methodInformation.responses[responseKey];
+        if (responseData === null || responseData === void 0 ? void 0 : responseData.content) {
+            const mediaType = responseData.content["application/json"];
+            if (mediaType === null || mediaType === void 0 ? void 0 : mediaType.schema) {
+                const refSchema = mediaType.schema.$ref;
+                if (refSchema) {
+                    responseBodySchema = refSchema.replace("#/components/schemas/", "");
+                    if (responseBodySchema.startsWith("Paginated")) {
+                        isList = true;
+                        responseBodySchema = responseBodySchema
+                            .replace("Paginated", "")
+                            .slice(0, -4);
+                    }
+                }
+            }
+        }
+    });
+    return [responseBodySchema, isList];
+}
+exports.extractResponseBodySchema = extractResponseBodySchema;

package/dist/schema/fetch-schema.d.ts

@@ -0,0 +1,7 @@
+import { ComponentsObject, PathsObject } from "@ts-stack/openapi-spec";
+interface OpenAPISchema {
+    paths: PathsObject;
+    components: ComponentsObject;
+}
+export declare function fetchSchema(url: string): Promise<OpenAPISchema>;
+export {};

package/dist/schema/fetch-schema.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchema = void 0;
+const axios_1 = __importDefault(require("axios"));
+function fetchSchema(url) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios_1.default.get(url);
+        return response.data;
+    });
+}
+exports.fetchSchema = fetchSchema;

package/dist/schema/remove-non-model-paths.d.ts

@@ -0,0 +1,2 @@
+import { PathsObject } from "@ts-stack/openapi-spec";
+export declare function removeNonModelPaths(paths: PathsObject): PathsObject;

package/dist/schema/remove-non-model-paths.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeNonModelPaths = void 0;
+function removeNonModelPaths(paths) {
+    const filteredPaths = {};
+    Object.keys(paths).forEach((key) => {
+        const appName = key.split("/")[2];
+        const modelName = key.split("/")[4];
+        if (appName && modelName) {
+            filteredPaths[key] = paths[key];
+        }
+    });
+    return filteredPaths;
+}
+exports.removeNonModelPaths = removeNonModelPaths;

package/dist/schema/to-camel-case.d.ts

@@ -0,0 +1 @@
+export declare function toCamelCase(str: string): string;

package/dist/schema/to-camel-case.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCamelCase = void 0;
+function toCamelCase(str) {
+    const pastel = str
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+    return pastel.charAt(0).toLowerCase() + pastel.slice(1);
+}
+exports.toCamelCase = toCamelCase;

package/dist/schema/to-pastel-case.d.ts

@@ -0,0 +1 @@
+export declare function toPascalCase(str: string): string;

package/dist/schema/to-pastel-case.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPascalCase = void 0;
+function toPascalCase(str) {
+    return str
+        .split("-")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+}
+exports.toPascalCase = toPascalCase;

package/dist/schema-convert.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-convert.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+function removeUnknownIndexSignature(code) {
+    return code
+        .split("\n")
+        .filter((line) => !line.includes("[k: string]: unknown;"))
+        .join("\n");
+}
+function removeDuplicates(code) {
+    const lines = code.split("\n");
+    const uniqueExports = new Set();
+    let filteredCode = "";
+    lines.forEach((line) => {
+        if (line.includes("export type ") && !uniqueExports.has(line)) {
+            uniqueExports.add(line);
+            filteredCode += line + "\n";
+        }
+        else if (!line.includes("export type ")) {
+            filteredCode += line + "\n";
+        }
+    });
+    return filteredCode;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Converting Schema");
+        const args = process.argv.slice(2);
+        const basePath = args[0];
+        const schemaFolderPath = (0, path_1.join)(basePath, "api-schema");
+        let interfaceFileData = "";
+        const schemaFiles = (0, fs_1.readdirSync)(schemaFolderPath);
+        let compilePromises = schemaFiles.map((schemaFile) => {
+            const schemaFilePath = (0, path_1.join)(schemaFolderPath, schemaFile);
+            return (0, json_schema_to_typescript_1.compileFromFile)(schemaFilePath, {
+                bannerComment: "",
+                style: { useTabs: false, tabWidth: 2 },
+                ignoreMinAndMaxItems: true,
+                strictIndexSignatures: false,
+            }).then((result) => {
+                const removedSignature = removeUnknownIndexSignature(result);
+                return removedSignature + "\n";
+            });
+        });
+        let results = yield Promise.all(compilePromises);
+        interfaceFileData = results.join("\n");
+        interfaceFileData = removeDuplicates(interfaceFileData);
+        const outputFile = (0, path_1.join)(basePath, "interface.ts");
+        (0, fs_1.writeFileSync)(outputFile, interfaceFileData);
+    });
+}
+main().catch((error) => console.error(error));

package/dist/schema-entities.d.ts

@@ -0,0 +1,14 @@
+import { PathsObject } from "@ts-stack/openapi-spec";
+import { EntitySyncMeta } from "./entity-generation/sync-method";
+/**
+ * Pre-pass over the OpenAPI paths: collects, per entity, the sync mode
+ * (from rastack's `x-rastack-sync` vendor extension), confirmed operations,
+ * the list/detail URLs, the row schema, and the list/detail operation ids
+ * (used to wire cache invalidation for non-sync entities).
+ */
+export declare function collectEntityMeta(paths: PathsObject): {
+    [indexKey: string]: EntitySyncMeta;
+};
+export declare function generateFolders(entitiesPath: string, paths: PathsObject): Promise<void>;
+export declare function generateFiles(entitiesPath: string, paths: PathsObject): Promise<void>;
+export declare function main(url: string, entitiesPath: string): Promise<void>;