rastack 0.0.16 → 0.0.20

package/src/define/index.ts

@@ -1,162 +1,162 @@
-/**
- * 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 const s = {
-  string(_opts?: StringOptions): Scalar<"string"> {
-    return { __radScalar: "string" } as Scalar<"string">;
-  },
-  int(_opts?: NumberOptions): Scalar<"int"> {
-    return { __radScalar: "int" } as Scalar<"int">;
-  },
-  float(_opts?: NumberOptions): Scalar<"float"> {
-    return { __radScalar: "float" } as Scalar<"float">;
-  },
-  bool(_opts?: BoolOptions): Scalar<"bool"> {
-    return { __radScalar: "bool" } as Scalar<"bool">;
-  },
-  datetime(_opts?: DateOptions): Scalar<"datetime"> {
-    return { __radScalar: "datetime" } as Scalar<"datetime">;
-  },
-  uuid(_opts?: StringOptions): Scalar<"uuid"> {
-    return { __radScalar: "uuid" } as 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> {
-    return { __radRef: true } as 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 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> {
-  return {
-    __rad: "resource",
-    __app: app,
-    __model: model,
-    app,
-    model,
-    fields,
-    options,
-  };
-}
+/**
+ * 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 const s = {
+  string(_opts?: StringOptions): Scalar<"string"> {
+    return { __radScalar: "string" } as Scalar<"string">;
+  },
+  int(_opts?: NumberOptions): Scalar<"int"> {
+    return { __radScalar: "int" } as Scalar<"int">;
+  },
+  float(_opts?: NumberOptions): Scalar<"float"> {
+    return { __radScalar: "float" } as Scalar<"float">;
+  },
+  bool(_opts?: BoolOptions): Scalar<"bool"> {
+    return { __radScalar: "bool" } as Scalar<"bool">;
+  },
+  datetime(_opts?: DateOptions): Scalar<"datetime"> {
+    return { __radScalar: "datetime" } as Scalar<"datetime">;
+  },
+  uuid(_opts?: StringOptions): Scalar<"uuid"> {
+    return { __radScalar: "uuid" } as 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> {
+    return { __radRef: true } as 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 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> {
+  return {
+    __rad: "resource",
+    __app: app,
+    __model: model,
+    app,
+    model,
+    fields,
+    options,
+  };
+}

package/src/entity-generation/delete-method.ts

@@ -1,37 +1,37 @@
-import { capitaliseFirstLetter } from "../schema/capitalise-first-letter";
-
-export function generateDeleteAPIMethod(
-  url: string,
-  operationId: string,
-  listQueryCacheKey?: string,
-): [string, Set<string>] {
-  const operationIdUpper = capitaliseFirstLetter(operationId);
-
-  let urlStructure = `'${url}'`;
-  const pathParams =
-    url.match(/{([^}]+)}/g)?.map((param) => param.slice(1, -1)) || [];
-
-  if (pathParams.length > 0) {
-    urlStructure = url.replace(/{([^}]+)}/g, "${$1}");
-    const paramList = pathParams.join(", ");
-    urlStructure = `(${paramList}) => \`${urlStructure}\``;
-  }
-
-  const importStatements = new Set<string>();
-  importStatements.add(`useDeleteQuery`);
-
-  const cacheKeyLine = listQueryCacheKey
-    ? `\n    listQueryCacheKey: ${listQueryCacheKey},`
-    : "";
-
-  return [
-    `
-export function use${operationIdUpper}() {
-  return useDeleteQuery({
-    deleteUrl: ${urlStructure},${cacheKeyLine}
-  });
-}
-`,
-    importStatements,
-  ];
-}
+import { capitaliseFirstLetter } from "../schema/capitalise-first-letter";
+
+export function generateDeleteAPIMethod(
+  url: string,
+  operationId: string,
+  listQueryCacheKey?: string,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+
+  let urlStructure = `'${url}'`;
+  const pathParams =
+    url.match(/{([^}]+)}/g)?.map((param) => param.slice(1, -1)) || [];
+
+  if (pathParams.length > 0) {
+    urlStructure = url.replace(/{([^}]+)}/g, "${$1}");
+    const paramList = pathParams.join(", ");
+    urlStructure = `(${paramList}) => \`${urlStructure}\``;
+  }
+
+  const importStatements = new Set<string>();
+  importStatements.add(`useDeleteQuery`);
+
+  const cacheKeyLine = listQueryCacheKey
+    ? `\n    listQueryCacheKey: ${listQueryCacheKey},`
+    : "";
+
+  return [
+    `
+export function use${operationIdUpper}() {
+  return useDeleteQuery({
+    deleteUrl: ${urlStructure},${cacheKeyLine}
+  });
+}
+`,
+    importStatements,
+  ];
+}