rastack 0.0.16

package/dist/compile/openapi.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiToJson = exports.buildOpenApi = void 0;
+/**
+ * Emit an OpenAPI 3 document from the analysed resources. The output reproduces
+ * the *exact* contract the existing `tools/` codegen and `stack/` runtime rely
+ * on — `/api/{app}/v1/{model}/` URL segments and the `x-rastack-sync*` vendor
+ * extensions — so those packages are unchanged. Foreign keys additionally carry
+ * a new `x-rastack-relation` extension so downstream tooling (and the admin) can
+ * follow relations.
+ */
+function buildOpenApi(resources) {
+    var _a;
+    const paths = {};
+    const schemas = {};
+    for (const resource of resources) {
+        const P = pascal(resource.model);
+        const listUrl = `/api/${resource.app}/v1/${resource.model}/`;
+        const detailUrl = `${listUrl}{id}/`;
+        const local = ((_a = resource.sync) === null || _a === void 0 ? void 0 : _a.mode) === "local";
+        schemas[P] = readSchema(resource);
+        schemas[`Paginated${P}List`] = paginatedSchema(P);
+        schemas[`${P}Request`] = writeSchema(resource, false);
+        schemas[`Patched${P}Request`] = writeSchema(resource, true);
+        paths[listUrl] = {
+            get: syncStamp({
+                operationId: `list${P}`,
+                parameters: [
+                    queryParam("page", "integer"),
+                    queryParam("search", "string"),
+                ],
+                responses: jsonResponse("200", `Paginated${P}List`),
+            }, resource, "list"),
+            post: syncStamp({
+                operationId: `create${P}`,
+                requestBody: jsonBody(`${P}Request`),
+                responses: jsonResponse("201", P),
+            }, resource, "create"),
+        };
+        paths[detailUrl] = {
+            get: syncStamp({
+                operationId: `get${P}ById`,
+                parameters: [idParam()],
+                responses: jsonResponse("200", P),
+            }, resource, "retrieve"),
+            put: syncStamp({
+                operationId: `update${P}`,
+                parameters: [idParam()],
+                requestBody: jsonBody(`${P}Request`),
+                responses: jsonResponse("200", P),
+            }, resource, "update"),
+            patch: syncStamp({
+                operationId: `partialUpdate${P}`,
+                parameters: [idParam()],
+                requestBody: jsonBody(`Patched${P}Request`),
+                responses: jsonResponse("200", P),
+            }, resource, "partial_update"),
+            delete: syncStamp({
+                operationId: `delete${P}`,
+                parameters: [idParam()],
+                responses: { "204": { description: "No response body" } },
+            }, resource, "destroy"),
+        };
+    }
+    return {
+        openapi: "3.0.3",
+        info: { title: "React API Stack", version: "1.0.0" },
+        paths,
+        components: { schemas },
+    };
+}
+exports.buildOpenApi = buildOpenApi;
+function openApiToJson(doc) {
+    return JSON.stringify(doc, null, 2) + "\n";
+}
+exports.openApiToJson = openApiToJson;
+// -- schema builders --------------------------------------------------------
+function readSchema(resource) {
+    const properties = {
+        id: idProperty(resource),
+    };
+    const required = [];
+    for (const field of resource.fields) {
+        properties[field.name] = fieldProperty(field);
+        if (!field.null && field.default === undefined)
+            required.push(field.name);
+    }
+    return { type: "object", properties, required };
+}
+function writeSchema(resource, patched) {
+    const properties = {};
+    const required = [];
+    for (const field of resource.fields) {
+        if (field.primaryKey)
+            continue;
+        properties[field.name] = fieldProperty(field);
+        if (!patched && !field.null && field.default === undefined) {
+            required.push(field.name);
+        }
+    }
+    const schema = { type: "object", properties };
+    if (required.length)
+        schema.required = required;
+    return schema;
+}
+function paginatedSchema(pascalModel) {
+    return {
+        type: "object",
+        properties: {
+            count: { type: "integer" },
+            next: { type: "string", nullable: true },
+            previous: { type: "string", nullable: true },
+            results: {
+                type: "array",
+                items: { $ref: `#/components/schemas/${pascalModel}` },
+            },
+        },
+        required: ["count", "results"],
+    };
+}
+function fieldProperty(field) {
+    if (field.type === "fk") {
+        return {
+            type: "integer",
+            "x-rastack-relation": field.relation,
+        };
+    }
+    const base = scalarProperty(field.type);
+    if (field.maxLength !== undefined)
+        base.maxLength = field.maxLength;
+    if (field.null)
+        base.nullable = true;
+    return base;
+}
+function idProperty(resource) {
+    var _a;
+    const pk = resource.fields.find((f) => f.primaryKey);
+    if (pk)
+        return Object.assign(Object.assign({}, scalarProperty(pk.type)), { readOnly: true });
+    if ((_a = resource.sync) === null || _a === void 0 ? void 0 : _a.clientIds) {
+        return { type: "string", format: "uuid" };
+    }
+    return { type: "integer", readOnly: true };
+}
+function scalarProperty(type) {
+    switch (type) {
+        case "int":
+            return { type: "integer" };
+        case "float":
+            return { type: "number" };
+        case "bool":
+            return { type: "boolean" };
+        case "datetime":
+            return { type: "string", format: "date-time" };
+        case "uuid":
+            return { type: "string", format: "uuid" };
+        default:
+            return { type: "string" };
+    }
+}
+// -- operation helpers ------------------------------------------------------
+function jsonResponse(status, schemaName) {
+    return {
+        [status]: {
+            description: "",
+            content: {
+                "application/json": {
+                    schema: { $ref: `#/components/schemas/${schemaName}` },
+                },
+            },
+        },
+    };
+}
+function jsonBody(schemaName) {
+    return {
+        required: true,
+        content: {
+            "application/json": {
+                schema: { $ref: `#/components/schemas/${schemaName}` },
+            },
+        },
+    };
+}
+function idParam() {
+    return {
+        name: "id",
+        in: "path",
+        required: true,
+        schema: { type: "string" },
+    };
+}
+function queryParam(name, type) {
+    return { name, in: "query", required: false, schema: { type } };
+}
+/**
+ * Stamp the `x-rastack-sync*` vendor extensions on an operation of a local-mode
+ * resource. Ported from the old `python/rastack/spectacular.py` postprocess
+ * hook: confirmed operations become blocking client hooks, everything else on a
+ * local resource replicates.
+ */
+function syncStamp(operation, resource, verb) {
+    const sync = resource.sync;
+    if (!sync || sync.mode !== "local")
+        return operation;
+    operation["x-rastack-sync"] = isConfirmed(sync.confirmed, verb, operation)
+        ? "confirmed"
+        : "local";
+    if (sync.load === "lazy")
+        operation["x-rastack-sync-load"] = "lazy";
+    if (sync.clientIds)
+        operation["x-rastack-sync-client-ids"] = true;
+    return operation;
+}
+function isConfirmed(confirmed, verb, operation) {
+    if (!confirmed || !confirmed.length)
+        return false;
+    for (const name of confirmed) {
+        if (name === verb)
+            return true;
+        if (name === "update" && verb === "partial_update")
+            return true;
+        if (operation.operationId && operation.operationId.includes(name)) {
+            return true;
+        }
+    }
+    return false;
+}
+function pascal(str) {
+    return str
+        .split(/[-_]/)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join("");
+}

package/dist/compile/program.d.ts

@@ -0,0 +1,10 @@
+import * as ts from "typescript";
+/**
+ * Build a `ts.Program` (and thus a `TypeChecker`) over a set of resource
+ * definition files. The DSL package (`rad-tools/define`) is mapped to the
+ * in-tree/installed sources via `paths` so both the shipped package name and
+ * the local demo/tests resolve without extra linking.
+ */
+export declare function createProgram(fileNames: string[]): ts.Program;
+/** Every non-declaration source file the program was rooted at. */
+export declare function resourceSourceFiles(program: ts.Program, fileNames: string[]): ts.SourceFile[];

package/dist/compile/program.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceSourceFiles = exports.createProgram = void 0;
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+/**
+ * Build a `ts.Program` (and thus a `TypeChecker`) over a set of resource
+ * definition files. The DSL package (`rad-tools/define`) is mapped to the
+ * in-tree/installed sources via `paths` so both the shipped package name and
+ * the local demo/tests resolve without extra linking.
+ */
+function createProgram(fileNames) {
+    const defineDir = path.resolve(__dirname, "../define");
+    const options = {
+        target: ts.ScriptTarget.ES2019,
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.Node10,
+        strict: true,
+        skipLibCheck: true,
+        esModuleInterop: true,
+        noEmit: true,
+        baseUrl: process.cwd(),
+        paths: {
+            "rad-tools/define": [defineDir],
+            "rad-tools/define/*": [defineDir + "/*"],
+        },
+    };
+    return ts.createProgram(fileNames, options);
+}
+exports.createProgram = createProgram;
+/** Every non-declaration source file the program was rooted at. */
+function resourceSourceFiles(program, fileNames) {
+    const wanted = new Set(fileNames.map((f) => path.resolve(f)));
+    return program
+        .getSourceFiles()
+        .filter((sf) => !sf.isDeclarationFile && wanted.has(path.resolve(sf.fileName)));
+}
+exports.resourceSourceFiles = resourceSourceFiles;

package/dist/csv-schema.d.ts

@@ -0,0 +1,28 @@
+export interface ColumnSchema {
+    name: string;
+    type: "integer" | "float" | "boolean" | "date" | "datetime" | "string";
+    nullable: boolean;
+    unique: boolean;
+    primaryKey: boolean;
+    pii: boolean;
+    piiReason?: string;
+}
+export interface TableSchema {
+    tableName: string;
+    sourceFile: string;
+    columns: ColumnSchema[];
+    rowCount: number;
+    fingerprint: string;
+}
+export declare function parseCsv(content: string): {
+    headers: string[];
+    rows: string[][];
+};
+export declare function inferSchema(csvPath: string, repoRoot: string): {
+    schema: TableSchema;
+    piiViolations: {
+        column: string;
+        reason: string;
+    }[];
+};
+export declare function discoverCsvFiles(dir: string): string[];

package/dist/csv-schema.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverCsvFiles = exports.inferSchema = exports.parseCsv = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const minimatch_1 = require("minimatch");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const DEFAULT_PII_PATTERNS = [
+    "*passport*",
+    "*_no",
+    "*_number",
+    "ssn",
+    "national_id",
+    "date_of_birth",
+    "dob",
+    "email",
+    "*phone*",
+    "*credit_card*",
+    "*card_number*",
+    "ip_address",
+    "latitude",
+    "longitude",
+    "*salary*",
+    "*income*",
+];
+function loadPiiConfig(repoRoot) {
+    const configPath = path_1.default.join(repoRoot, ".rad", "pii-patterns.yml");
+    if (!fs_1.default.existsSync(configPath)) {
+        return { patterns: DEFAULT_PII_PATTERNS, luhn_check: true, require_policy: true };
+    }
+    return js_yaml_1.default.load(fs_1.default.readFileSync(configPath, "utf-8"));
+}
+function isPiiColumn(name, config) {
+    const lower = name.toLowerCase();
+    for (const pattern of config.patterns) {
+        if ((0, minimatch_1.minimatch)(lower, pattern.toLowerCase())) {
+            return `matches PII pattern "${pattern}"`;
+        }
+    }
+    return null;
+}
+function luhnCheck(value) {
+    const digits = value.replace(/\D/g, "");
+    if (digits.length < 13)
+        return false;
+    let sum = 0;
+    let alternate = false;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let n = parseInt(digits[i], 10);
+        if (alternate) {
+            n *= 2;
+            if (n > 9)
+                n -= 9;
+        }
+        sum += n;
+        alternate = !alternate;
+    }
+    return sum % 10 === 0;
+}
+function inferType(values) {
+    const nonEmpty = values.filter((v) => v.trim() !== "" && v.toLowerCase() !== "null");
+    if (nonEmpty.length === 0)
+        return "string";
+    if (nonEmpty.every((v) => /^\d+$/.test(v.trim())))
+        return "integer";
+    if (nonEmpty.every((v) => /^-?\d+(\.\d+)?$/.test(v.trim())))
+        return "float";
+    if (nonEmpty.every((v) => /^(true|false|yes|no|1|0)$/i.test(v.trim())))
+        return "boolean";
+    if (nonEmpty.every((v) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(v.trim())))
+        return "datetime";
+    if (nonEmpty.every((v) => /^\d{4}-\d{2}-\d{2}$/.test(v.trim())))
+        return "date";
+    return "string";
+}
+function parseCsv(content) {
+    const lines = content.split(/\r?\n/).filter((l) => l.trim() !== "");
+    if (lines.length === 0)
+        return { headers: [], rows: [] };
+    const splitLine = (line) => {
+        const result = [];
+        let current = "";
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            if (line[i] === '"') {
+                inQuotes = !inQuotes;
+            }
+            else if (line[i] === "," && !inQuotes) {
+                result.push(current.trim());
+                current = "";
+            }
+            else {
+                current += line[i];
+            }
+        }
+        result.push(current.trim());
+        return result;
+    };
+    const headers = splitLine(lines[0]);
+    const rows = lines.slice(1).map(splitLine);
+    return { headers, rows };
+}
+exports.parseCsv = parseCsv;
+function fingerprint(schema) {
+    const sig = schema.columns.map((c) => `${c.name}:${c.type}:${c.pii}`).join("|");
+    // Simple hash — not crypto, just change-detection
+    let h = 0;
+    for (let i = 0; i < sig.length; i++) {
+        h = (Math.imul(31, h) + sig.charCodeAt(i)) | 0;
+    }
+    return Math.abs(h).toString(16).padStart(8, "0");
+}
+function inferSchema(csvPath, repoRoot) {
+    const content = fs_1.default.readFileSync(csvPath, "utf-8");
+    const { headers, rows } = parseCsv(content);
+    const piiConfig = loadPiiConfig(repoRoot);
+    const tableName = path_1.default.basename(csvPath, ".csv");
+    const piiViolations = [];
+    const columns = headers.map((name, i) => {
+        const values = rows.map((r) => { var _a; return (_a = r[i]) !== null && _a !== void 0 ? _a : ""; });
+        const type = inferType(values);
+        const nullable = values.some((v) => v.trim() === "" || v.toLowerCase() === "null");
+        const nonEmpty = values.filter((v) => v.trim() !== "");
+        const unique = new Set(nonEmpty).size === nonEmpty.length;
+        const isPrimary = name.toLowerCase() === "id";
+        // PII: column name pattern match
+        let pii = false;
+        let piiReason;
+        const nameReason = isPiiColumn(name, piiConfig);
+        if (nameReason) {
+            pii = true;
+            piiReason = nameReason;
+        }
+        // PII: Luhn check on string columns that look numeric
+        if (!pii && piiConfig.luhn_check && type === "string") {
+            const luhnHits = values.filter((v) => v.trim() !== "" && luhnCheck(v));
+            if (luhnHits.length > values.length * 0.5) {
+                pii = true;
+                piiReason = "majority of values pass Luhn check (possible card numbers)";
+            }
+        }
+        if (pii && piiReason) {
+            piiViolations.push({ column: name, reason: piiReason });
+        }
+        return { name, type, nullable, unique, primaryKey: isPrimary, pii, piiReason };
+    });
+    const base = { tableName, sourceFile: csvPath, columns, rowCount: rows.length };
+    return { schema: Object.assign(Object.assign({}, base), { fingerprint: fingerprint(base) }), piiViolations };
+}
+exports.inferSchema = inferSchema;
+function discoverCsvFiles(dir) {
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((f) => f.endsWith(".csv"))
+        .map((f) => path_1.default.join(dir, f));
+}
+exports.discoverCsvFiles = discoverCsvFiles;

package/dist/define/index.d.ts

@@ -0,0 +1,117 @@
+/**
+ * rad-tools authoring DSL — the TypeScript-first source of truth.
+ *
+ * Resources are authored as plain TypeScript. The compiler
+ * (`tools/src/compile`) reads these definitions and, crucially, **infers
+ * foreign-key relations directly from the field types** via the TypeScript type
+ * checker: a field whose type is a {@link Ref} to another {@link ResourceType}
+ * is recorded as a foreign key, with the target app/model recovered from the
+ * `Ref`'s string-literal type arguments.
+ *
+ * ```ts
+ * import { resource, s } from "rad-tools/define";
+ *
+ * export const Airport = resource("airports", "airport", {
+ *   code: s.string({ maxLength: 3, unique: true }),
+ *   name: s.string({ maxLength: 120 }),
+ * }, { search: ["code", "name"], admin: { listDisplay: ["code", "name"] } });
+ *
+ * export const Terminal = resource("airports", "terminal", {
+ *   airport: s.ref(() => Airport),   // FK inferred from the type of this field
+ *   label: s.string({ maxLength: 20 }),
+ * });
+ * ```
+ */
+/** A scalar field. The literal `__radScalar` type is what the compiler reads. */
+export interface Scalar<T extends string> {
+    readonly __radScalar: T;
+}
+/**
+ * A foreign-key field. `App`/`Model` are carried as string-literal type
+ * arguments so the compiler can recover the relation target purely from types.
+ */
+export interface Ref<App extends string, Model extends string> {
+    readonly __radRef: true;
+    readonly __app: App;
+    readonly __model: Model;
+}
+export interface StringOptions {
+    maxLength?: number;
+    unique?: boolean;
+    primaryKey?: boolean;
+    default?: string;
+    null?: boolean;
+}
+export interface NumberOptions {
+    unique?: boolean;
+    primaryKey?: boolean;
+    default?: number;
+    null?: boolean;
+}
+export interface BoolOptions {
+    default?: boolean;
+    null?: boolean;
+}
+export interface DateOptions {
+    autoNow?: boolean;
+    autoNowAdd?: boolean;
+    null?: boolean;
+}
+/**
+ * Field builders. Each returns a phantom value whose *type* encodes the field
+ * kind; the runtime object is never used at compile time (the compiler analyses
+ * the source, it does not execute it) but is real so the DSL is also usable at
+ * runtime if a consumer wants it.
+ */
+export declare const s: {
+    string(_opts?: StringOptions): Scalar<"string">;
+    int(_opts?: NumberOptions): Scalar<"int">;
+    float(_opts?: NumberOptions): Scalar<"float">;
+    bool(_opts?: BoolOptions): Scalar<"bool">;
+    datetime(_opts?: DateOptions): Scalar<"datetime">;
+    uuid(_opts?: StringOptions): Scalar<"uuid">;
+    /**
+     * A foreign key. The target is `() => SomeResource`; the compiler resolves
+     * the relation from the *type* `Ref<App, Model>` this returns — it does not
+     * need to run the thunk.
+     */
+    ref<A extends string, M extends string>(_thunk: () => ResourceType<A, M, any>): Ref<A, M>;
+};
+export type AnyField = Scalar<string> | Ref<string, string>;
+/** Local-first sync configuration (mirrors the old Python `class Sync:`). */
+export interface SyncOptions {
+    mode?: "server" | "local";
+    scope?: string;
+    confirmed?: string[];
+    load?: "instant" | "lazy";
+    clientIds?: boolean;
+}
+export interface ResourceOptions {
+    /** DRF-style search fields. */
+    search?: string[];
+    /** Orderable fields. */
+    ordering?: string[];
+    /** Admin config, or `false` to opt out of the admin. */
+    admin?: {
+        listDisplay?: string[];
+    } | false;
+    /** Local-first replication config. */
+    sync?: SyncOptions;
+    /** Access policy (secure by default). */
+    permission?: "authenticatedOrReadOnly" | "authenticated" | "public";
+}
+/**
+ * A resource definition. `App`/`Model` are preserved as string-literal type
+ * arguments so a {@link Ref} to this resource carries a recoverable target.
+ */
+export interface ResourceType<App extends string, Model extends string, F> {
+    readonly __rad: "resource";
+    readonly __app: App;
+    readonly __model: Model;
+    readonly app: App;
+    readonly model: Model;
+    readonly fields: F;
+    readonly options: ResourceOptions;
+}
+/** Define a resource. Capture app/model as literal types for FK inference. */
+export declare function resource<App extends string, Model extends string, F extends Record<string, AnyField>>(app: App, model: Model, fields: F, options?: ResourceOptions): ResourceType<App, Model, F>;

package/dist/define/index.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * rad-tools authoring DSL — the TypeScript-first source of truth.
+ *
+ * Resources are authored as plain TypeScript. The compiler
+ * (`tools/src/compile`) reads these definitions and, crucially, **infers
+ * foreign-key relations directly from the field types** via the TypeScript type
+ * checker: a field whose type is a {@link Ref} to another {@link ResourceType}
+ * is recorded as a foreign key, with the target app/model recovered from the
+ * `Ref`'s string-literal type arguments.
+ *
+ * ```ts
+ * import { resource, s } from "rad-tools/define";
+ *
+ * export const Airport = resource("airports", "airport", {
+ *   code: s.string({ maxLength: 3, unique: true }),
+ *   name: s.string({ maxLength: 120 }),
+ * }, { search: ["code", "name"], admin: { listDisplay: ["code", "name"] } });
+ *
+ * export const Terminal = resource("airports", "terminal", {
+ *   airport: s.ref(() => Airport),   // FK inferred from the type of this field
+ *   label: s.string({ maxLength: 20 }),
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resource = exports.s = void 0;
+/**
+ * Field builders. Each returns a phantom value whose *type* encodes the field
+ * kind; the runtime object is never used at compile time (the compiler analyses
+ * the source, it does not execute it) but is real so the DSL is also usable at
+ * runtime if a consumer wants it.
+ */
+exports.s = {
+    string(_opts) {
+        return { __radScalar: "string" };
+    },
+    int(_opts) {
+        return { __radScalar: "int" };
+    },
+    float(_opts) {
+        return { __radScalar: "float" };
+    },
+    bool(_opts) {
+        return { __radScalar: "bool" };
+    },
+    datetime(_opts) {
+        return { __radScalar: "datetime" };
+    },
+    uuid(_opts) {
+        return { __radScalar: "uuid" };
+    },
+    /**
+     * A foreign key. The target is `() => SomeResource`; the compiler resolves
+     * the relation from the *type* `Ref<App, Model>` this returns — it does not
+     * need to run the thunk.
+     */
+    ref(_thunk) {
+        return { __radRef: true };
+    },
+};
+/** Define a resource. Capture app/model as literal types for FK inference. */
+function resource(app, model, fields, options = {}) {
+    return {
+        __rad: "resource",
+        __app: app,
+        __model: model,
+        app,
+        model,
+        fields,
+        options,
+    };
+}
+exports.resource = resource;

package/dist/entity-generation/delete-method.d.ts

@@ -0,0 +1 @@
+export declare function generateDeleteAPIMethod(url: string, operationId: string, listQueryCacheKey?: string): [string, Set<string>];