rastack 0.0.16 → 0.0.19

package/src/compile/model.ts

@@ -1,69 +1,69 @@
-/**
- * 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[];
-}
+/**
+ * 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/src/compile/openapi.ts

@@ -1,266 +1,266 @@
-import { FieldModel, 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 function buildOpenApi(resources: ResourceModel[]): any {
-  const paths: Record<string, any> = {};
-  const schemas: Record<string, any> = {};
-
-  for (const resource of resources) {
-    const P = pascal(resource.model);
-    const listUrl = `/api/${resource.app}/v1/${resource.model}/`;
-    const detailUrl = `${listUrl}{id}/`;
-    const local = resource.sync?.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 },
-  };
-}
-
-export function openApiToJson(doc: any): string {
-  return JSON.stringify(doc, null, 2) + "\n";
-}
-
-// -- schema builders --------------------------------------------------------
-
-function readSchema(resource: ResourceModel): any {
-  const properties: Record<string, any> = {
-    id: idProperty(resource),
-  };
-  const required: string[] = [];
-  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: ResourceModel, patched: boolean): any {
-  const properties: Record<string, any> = {};
-  const required: string[] = [];
-  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: any = { type: "object", properties };
-  if (required.length) schema.required = required;
-  return schema;
-}
-
-function paginatedSchema(pascalModel: string): any {
-  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: FieldModel): any {
-  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: ResourceModel): any {
-  const pk = resource.fields.find((f) => f.primaryKey);
-  if (pk) return { ...scalarProperty(pk.type), readOnly: true };
-  if (resource.sync?.clientIds) {
-    return { type: "string", format: "uuid" };
-  }
-  return { type: "integer", readOnly: true };
-}
-
-function scalarProperty(type: string): any {
-  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: string, schemaName: string): any {
-  return {
-    [status]: {
-      description: "",
-      content: {
-        "application/json": {
-          schema: { $ref: `#/components/schemas/${schemaName}` },
-        },
-      },
-    },
-  };
-}
-
-function jsonBody(schemaName: string): any {
-  return {
-    required: true,
-    content: {
-      "application/json": {
-        schema: { $ref: `#/components/schemas/${schemaName}` },
-      },
-    },
-  };
-}
-
-function idParam(): any {
-  return {
-    name: "id",
-    in: "path",
-    required: true,
-    schema: { type: "string" },
-  };
-}
-
-function queryParam(name: string, type: string): any {
-  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: any, resource: ResourceModel, verb: string): any {
-  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: string[] | undefined,
-  verb: string,
-  operation: any,
-): boolean {
-  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: string): string {
-  return str
-    .split(/[-_]/)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-    .join("");
-}
+import { FieldModel, 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 function buildOpenApi(resources: ResourceModel[]): any {
+  const paths: Record<string, any> = {};
+  const schemas: Record<string, any> = {};
+
+  for (const resource of resources) {
+    const P = pascal(resource.model);
+    const listUrl = `/api/${resource.app}/v1/${resource.model}/`;
+    const detailUrl = `${listUrl}{id}/`;
+    const local = resource.sync?.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 },
+  };
+}
+
+export function openApiToJson(doc: any): string {
+  return JSON.stringify(doc, null, 2) + "\n";
+}
+
+// -- schema builders --------------------------------------------------------
+
+function readSchema(resource: ResourceModel): any {
+  const properties: Record<string, any> = {
+    id: idProperty(resource),
+  };
+  const required: string[] = [];
+  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: ResourceModel, patched: boolean): any {
+  const properties: Record<string, any> = {};
+  const required: string[] = [];
+  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: any = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+
+function paginatedSchema(pascalModel: string): any {
+  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: FieldModel): any {
+  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: ResourceModel): any {
+  const pk = resource.fields.find((f) => f.primaryKey);
+  if (pk) return { ...scalarProperty(pk.type), readOnly: true };
+  if (resource.sync?.clientIds) {
+    return { type: "string", format: "uuid" };
+  }
+  return { type: "integer", readOnly: true };
+}
+
+function scalarProperty(type: string): any {
+  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: string, schemaName: string): any {
+  return {
+    [status]: {
+      description: "",
+      content: {
+        "application/json": {
+          schema: { $ref: `#/components/schemas/${schemaName}` },
+        },
+      },
+    },
+  };
+}
+
+function jsonBody(schemaName: string): any {
+  return {
+    required: true,
+    content: {
+      "application/json": {
+        schema: { $ref: `#/components/schemas/${schemaName}` },
+      },
+    },
+  };
+}
+
+function idParam(): any {
+  return {
+    name: "id",
+    in: "path",
+    required: true,
+    schema: { type: "string" },
+  };
+}
+
+function queryParam(name: string, type: string): any {
+  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: any, resource: ResourceModel, verb: string): any {
+  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: string[] | undefined,
+  verb: string,
+  operation: any,
+): boolean {
+  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: string): string {
+  return str
+    .split(/[-_]/)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join("");
+}