rastack 0.0.16

package/dist/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "tabWidth": 2,
+  "semi": true,
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "printWidth": 80
+}

package/dist/compile/analyze.d.ts

@@ -0,0 +1,12 @@
+import * as ts from "typescript";
+import { ResourceModel } from "./model";
+/**
+ * Statically analyse resource definitions and produce the canonical model.
+ *
+ * The headline behaviour is **foreign-key inference from types**: for every
+ * field we ask the `TypeChecker` for the field's type and, if that type is a
+ * `Ref<App, Model>`, we recover the relation target from the `__app`/`__model`
+ * string-literal type arguments. No runtime execution, no string heuristics on
+ * the value — the relation is read straight out of the type system.
+ */
+export declare function analyze(program: ts.Program, fileNames: string[]): ResourceModel[];

package/dist/compile/analyze.js

@@ -0,0 +1,233 @@
+"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.analyze = void 0;
+const ts = __importStar(require("typescript"));
+const program_1 = require("./program");
+/**
+ * Statically analyse resource definitions and produce the canonical model.
+ *
+ * The headline behaviour is **foreign-key inference from types**: for every
+ * field we ask the `TypeChecker` for the field's type and, if that type is a
+ * `Ref<App, Model>`, we recover the relation target from the `__app`/`__model`
+ * string-literal type arguments. No runtime execution, no string heuristics on
+ * the value — the relation is read straight out of the type system.
+ */
+function analyze(program, fileNames) {
+    const checker = program.getTypeChecker();
+    const resources = [];
+    for (const sourceFile of (0, program_1.resourceSourceFiles)(program, fileNames)) {
+        ts.forEachChild(sourceFile, function walk(node) {
+            if (isResourceCall(node)) {
+                const model = analyzeResourceCall(node, checker);
+                if (model)
+                    resources.push(model);
+            }
+            ts.forEachChild(node, walk);
+        });
+    }
+    // Deterministic order: app, then model.
+    resources.sort((a, b) => a.app === b.app ? a.model.localeCompare(b.model) : a.app.localeCompare(b.app));
+    return resources;
+}
+exports.analyze = analyze;
+function isResourceCall(node) {
+    return (ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === "resource" &&
+        node.arguments.length >= 3);
+}
+function analyzeResourceCall(call, checker) {
+    var _a;
+    const app = stringLiteralArg(call.arguments[0]);
+    const model = stringLiteralArg(call.arguments[1]);
+    const fieldsArg = call.arguments[2];
+    if (!app || !model || !fieldsArg || !ts.isObjectLiteralExpression(fieldsArg)) {
+        return undefined;
+    }
+    const fields = [];
+    const relations = [];
+    for (const prop of fieldsArg.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = propertyName(prop.name);
+        if (!name)
+            continue;
+        const field = analyzeField(name, prop.initializer, checker);
+        if (!field)
+            continue;
+        fields.push(field);
+        if (field.type === "fk" && field.relation) {
+            relations.push({
+                field: name,
+                target: `${field.relation.app}.${field.relation.model}`,
+                kind: "fk",
+            });
+        }
+    }
+    const options = (_a = literalToValue(call.arguments[3])) !== null && _a !== void 0 ? _a : {};
+    return {
+        app,
+        model,
+        fields,
+        relations,
+        sync: normaliseSync(options.sync),
+        admin: normaliseAdmin(options.admin),
+        search: options.search,
+        ordering: options.ordering,
+        permission: options.permission,
+    };
+}
+/**
+ * Resolve a single field from its initializer. FK detection is type-driven:
+ * the initializer's *type* is inspected, and a `Ref` type yields a foreign key.
+ */
+function analyzeField(name, initializer, checker) {
+    const fieldType = checker.getTypeAtLocation(initializer);
+    // Foreign key: the field type is Ref<App, Model>. Recover the target from
+    // the string-literal type arguments — this is the "infer FK from types" step.
+    if (fieldType.getProperty("__radRef")) {
+        const app = literalTypeProp(fieldType, "__app", checker, initializer);
+        const model = literalTypeProp(fieldType, "__model", checker, initializer);
+        if (app && model) {
+            return { name, type: "fk", relation: { app, model } };
+        }
+        return undefined;
+    }
+    // Scalar: the field type carries a `__radScalar` string-literal discriminant.
+    const scalar = literalTypeProp(fieldType, "__radScalar", checker, initializer);
+    if (!scalar)
+        return undefined;
+    const field = { name, type: scalar };
+    applyConstraints(field, initializer);
+    return field;
+}
+/** Read scalar constraints (maxLength, unique, …) from the builder call args. */
+function applyConstraints(field, initializer) {
+    if (!ts.isCallExpression(initializer))
+        return;
+    const opts = literalToValue(initializer.arguments[0]);
+    if (!opts || typeof opts !== "object")
+        return;
+    if (typeof opts.maxLength === "number")
+        field.maxLength = opts.maxLength;
+    if (opts.unique === true)
+        field.unique = true;
+    if (opts.primaryKey === true)
+        field.primaryKey = true;
+    if (opts.null === true)
+        field.null = true;
+    if (opts.default !== undefined)
+        field.default = opts.default;
+}
+// -- type/AST helpers -------------------------------------------------------
+/** Read a string-literal-typed property (e.g. `__app: "airports"`) off a type. */
+function literalTypeProp(type, name, checker, location) {
+    const symbol = type.getProperty(name);
+    if (!symbol)
+        return undefined;
+    const propType = checker.getTypeOfSymbolAtLocation(symbol, location);
+    if (propType.isStringLiteral())
+        return propType.value;
+    return undefined;
+}
+function stringLiteralArg(node) {
+    if (node && ts.isStringLiteralLike(node))
+        return node.text;
+    return undefined;
+}
+function propertyName(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name))
+        return name.text;
+    return undefined;
+}
+/**
+ * Evaluate a *static literal* AST node (string/number/bool/null/array/object)
+ * into a JS value. Anything non-literal (a function, an identifier) yields
+ * `undefined` — the options and constraint blocks are always literals.
+ */
+function literalToValue(node) {
+    if (!node)
+        return undefined;
+    if (ts.isStringLiteralLike(node))
+        return node.text;
+    if (ts.isNumericLiteral(node))
+        return Number(node.text);
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    if (ts.isPrefixUnaryExpression(node) &&
+        node.operator === ts.SyntaxKind.MinusToken) {
+        const inner = literalToValue(node.operand);
+        return typeof inner === "number" ? -inner : undefined;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return node.elements.map((el) => literalToValue(el));
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const obj = {};
+        for (const p of node.properties) {
+            if (ts.isPropertyAssignment(p)) {
+                const key = propertyName(p.name);
+                if (key)
+                    obj[key] = literalToValue(p.initializer);
+            }
+        }
+        return obj;
+    }
+    return undefined;
+}
+function normaliseSync(sync) {
+    if (!sync || typeof sync !== "object")
+        return undefined;
+    const mode = sync.mode === "local" ? "local" : "server";
+    if (mode === "server" && !sync.confirmed) {
+        // A bare server resource carries no sync semantics.
+        return undefined;
+    }
+    const model = { mode };
+    if (typeof sync.scope === "string")
+        model.scope = sync.scope;
+    if (Array.isArray(sync.confirmed))
+        model.confirmed = sync.confirmed;
+    if (sync.load === "lazy")
+        model.load = "lazy";
+    if (sync.clientIds === true)
+        model.clientIds = true;
+    return model;
+}
+function normaliseAdmin(admin) {
+    if (admin === false)
+        return false;
+    if (!admin || typeof admin !== "object")
+        return undefined;
+    const model = {};
+    if (Array.isArray(admin.listDisplay))
+        model.listDisplay = admin.listDisplay;
+    return model;
+}

package/dist/compile/index.d.ts

@@ -0,0 +1,19 @@
+import { Manifest, ResourceModel } from "./model";
+export { analyze } from "./analyze";
+export { buildManifest } from "./manifest";
+export { buildOpenApi } from "./openapi";
+export * from "./model";
+export interface CompileResult {
+    manifest: Manifest;
+    openapi: any;
+    files: string[];
+}
+/** List every `.ts` resource file under a directory (or accept explicit files). */
+export declare function resolveResourceFiles(input: string): string[];
+/** Analyse resource definitions into the canonical model (no file output). */
+export declare function analyzeResources(input: string): ResourceModel[];
+/** Compile resource definitions to a manifest + OpenAPI, writing both to disk. */
+export declare function compile(input: string, outDir: string): CompileResult;
+/** Detect duplicate `app.model` definitions and dangling FK targets. */
+export declare function collisions(resources: ResourceModel[]): string[];
+export declare function urlsFor(resources: ResourceModel[]): string[];

package/dist/compile/index.js

@@ -0,0 +1,107 @@
+"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;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlsFor = exports.collisions = exports.compile = exports.analyzeResources = exports.resolveResourceFiles = exports.buildOpenApi = exports.buildManifest = exports.analyze = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const analyze_1 = require("./analyze");
+const manifest_1 = require("./manifest");
+const openapi_1 = require("./openapi");
+const program_1 = require("./program");
+var analyze_2 = require("./analyze");
+Object.defineProperty(exports, "analyze", { enumerable: true, get: function () { return analyze_2.analyze; } });
+var manifest_2 = require("./manifest");
+Object.defineProperty(exports, "buildManifest", { enumerable: true, get: function () { return manifest_2.buildManifest; } });
+var openapi_2 = require("./openapi");
+Object.defineProperty(exports, "buildOpenApi", { enumerable: true, get: function () { return openapi_2.buildOpenApi; } });
+__exportStar(require("./model"), exports);
+/** List every `.ts` resource file under a directory (or accept explicit files). */
+function resolveResourceFiles(input) {
+    const stat = fs.existsSync(input) ? fs.statSync(input) : undefined;
+    if (stat === null || stat === void 0 ? void 0 : stat.isFile())
+        return [path.resolve(input)];
+    if (stat === null || stat === void 0 ? void 0 : stat.isDirectory()) {
+        return fs
+            .readdirSync(input)
+            .filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"))
+            .map((f) => path.resolve(input, f))
+            .sort();
+    }
+    throw new Error(`No such resources path: ${input}`);
+}
+exports.resolveResourceFiles = resolveResourceFiles;
+/** Analyse resource definitions into the canonical model (no file output). */
+function analyzeResources(input) {
+    const files = resolveResourceFiles(input);
+    const program = (0, program_1.createProgram)(files);
+    return (0, analyze_1.analyze)(program, files);
+}
+exports.analyzeResources = analyzeResources;
+/** Compile resource definitions to a manifest + OpenAPI, writing both to disk. */
+function compile(input, outDir) {
+    const resources = analyzeResources(input);
+    const manifest = (0, manifest_1.buildManifest)(resources);
+    const openapi = (0, openapi_1.buildOpenApi)(resources);
+    fs.mkdirSync(outDir, { recursive: true });
+    const manifestPath = path.join(outDir, "schema.rad.json");
+    const openapiPath = path.join(outDir, "openapi.json");
+    fs.writeFileSync(manifestPath, (0, manifest_1.manifestToJson)(manifest), { flag: "w" });
+    fs.writeFileSync(openapiPath, (0, openapi_1.openApiToJson)(openapi), { flag: "w" });
+    return { manifest, openapi, files: [manifestPath, openapiPath] };
+}
+exports.compile = compile;
+// -- introspection (replaces `manage.py rastack check|list|urls`) -----------
+/** Detect duplicate `app.model` definitions and dangling FK targets. */
+function collisions(resources) {
+    var _a;
+    const errors = [];
+    const seen = new Map();
+    const keys = new Set(resources.map((r) => `${r.app}.${r.model}`));
+    for (const r of resources) {
+        const key = `${r.app}.${r.model}`;
+        seen.set(key, ((_a = seen.get(key)) !== null && _a !== void 0 ? _a : 0) + 1);
+        for (const rel of r.relations) {
+            if (!keys.has(rel.target)) {
+                errors.push(`${key}.${rel.field} references unknown resource ${rel.target}.`);
+            }
+        }
+    }
+    for (const [key, count] of seen) {
+        if (count > 1)
+            errors.push(`Duplicate resource ${key} defined ${count} times.`);
+    }
+    return errors;
+}
+exports.collisions = collisions;
+function urlsFor(resources) {
+    return resources.flatMap((r) => [
+        `/api/${r.app}/v1/${r.model}/`,
+        `/api/${r.app}/v1/${r.model}/{id}/`,
+    ]);
+}
+exports.urlsFor = urlsFor;

package/dist/compile/manifest.d.ts

@@ -0,0 +1,4 @@
+import { Manifest, ResourceModel } from "./model";
+/** Assemble the canonical manifest from analysed resources. */
+export declare function buildManifest(resources: ResourceModel[]): Manifest;
+export declare function manifestToJson(manifest: Manifest): string;

package/dist/compile/manifest.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifestToJson = exports.buildManifest = void 0;
+/** Assemble the canonical manifest from analysed resources. */
+function buildManifest(resources) {
+    return { version: 1, resources };
+}
+exports.buildManifest = buildManifest;
+function manifestToJson(manifest) {
+    return JSON.stringify(manifest, null, 2) + "\n";
+}
+exports.manifestToJson = manifestToJson;

package/dist/compile/model.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The canonical, backend-agnostic data model produced by the compiler. This is
+ * what `schema.rad.json` serializes and what both the OpenAPI emitter and the
+ * Rust API consume.
+ */
+export type ScalarType = "string" | "int" | "float" | "bool" | "datetime" | "uuid";
+export type FieldType = ScalarType | "fk";
+export interface RelationTarget {
+    app: string;
+    model: string;
+}
+export interface FieldModel {
+    name: string;
+    type: FieldType;
+    maxLength?: number;
+    unique?: boolean;
+    primaryKey?: boolean;
+    null?: boolean;
+    default?: unknown;
+    /** Present iff `type === "fk"` — the resource this field points at. */
+    relation?: RelationTarget;
+}
+export interface RelationModel {
+    /** The field on *this* resource that holds the foreign key. */
+    field: string;
+    /** `"app.model"` of the referenced resource. */
+    target: string;
+    kind: "fk";
+}
+export interface SyncModel {
+    mode: "server" | "local";
+    scope?: string;
+    confirmed?: string[];
+    load?: "instant" | "lazy";
+    clientIds?: boolean;
+}
+export interface AdminModel {
+    listDisplay?: string[];
+}
+export interface ResourceModel {
+    app: string;
+    model: string;
+    fields: FieldModel[];
+    relations: RelationModel[];
+    sync?: SyncModel;
+    admin?: AdminModel | false;
+    search?: string[];
+    ordering?: string[];
+    permission?: string;
+}
+export interface Manifest {
+    version: 1;
+    resources: ResourceModel[];
+}

package/dist/compile/model.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * The canonical, backend-agnostic data model produced by the compiler. This is
+ * what `schema.rad.json` serializes and what both the OpenAPI emitter and the
+ * Rust API consume.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/compile/openapi.d.ts

@@ -0,0 +1,11 @@
+import { ResourceModel } from "./model";
+/**
+ * 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.
+ */
+export declare function buildOpenApi(resources: ResourceModel[]): any;
+export declare function openApiToJson(doc: any): string;