@ghentcdh/crouton-api 0.0.1-alpha.2 → 0.0.1-alpha.21

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc2) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -27,6 +37,8 @@ __export(index_exports, {
   ResourceConfigLoader: () => ResourceConfigLoader2,
   ResourceConfigRegistry: () => ResourceConfigRegistry,
   isOperationEnabled: () => isOperationEnabled,
+  isRowProcedureAction: () => isRowProcedureAction,
+  isTableProcedureAction: () => isTableProcedureAction,
   loadDataSourcesFromDir: () => loadDataSourcesFromDir,
   loadResourceConfigsFromDir: () => loadResourceConfigsFromDir,
   resolveDefinition: () => resolveDefinition,
@@ -36,20 +48,36 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/lib/crouton-api.module.ts
-var import_common13 = require("@nestjs/common");
+var import_common12 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
-// src/lib/crud/app-layout.controller.ts
-var import_common2 = require("@nestjs/common");
-var import_swagger = require("@nestjs/swagger");
+// src/lib/crud/app-layout/app-layout.types.ts
+var import_zod = require("zod");
+var SidebarLeafSchema = import_zod.z.object({
+  kind: import_zod.z.literal("item").default("item"),
+  id: import_zod.z.string(),
+  label: import_zod.z.string(),
+  position: import_zod.z.number().optional()
+});
+var SidebarGroupSchema = import_zod.z.object({
+  kind: import_zod.z.literal("group").default("group"),
+  id: import_zod.z.string(),
+  label: import_zod.z.string(),
+  position: import_zod.z.number().optional(),
+  children: import_zod.z.array(SidebarLeafSchema).default([])
+});
+var SidebarNodeSchema = import_zod.z.discriminatedUnion("kind", [
+  SidebarLeafSchema,
+  SidebarGroupSchema
+]);
 
 // ../crouton-core/src/lib/request.model.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // ../crouton-core/src/lib/zod.types.ts
-var import_zod = require("zod");
-var PositiveRequestNumber = /* @__PURE__ */ __name(() => import_zod.z.coerce.number().int().positive().nonnegative(), "PositiveRequestNumber");
-var StringOrArray = /* @__PURE__ */ __name(() => import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).transform((val) => {
+var import_zod2 = require("zod");
+var PositiveRequestNumber = /* @__PURE__ */ __name(() => import_zod2.z.coerce.number().int().positive().nonnegative(), "PositiveRequestNumber");
+var StringOrArray = /* @__PURE__ */ __name(() => import_zod2.z.string().or(import_zod2.z.array(import_zod2.z.string())).transform((val) => {
   if (Array.isArray(val)) return val;
   return [
     val
@@ -57,14 +85,14 @@ var StringOrArray = /* @__PURE__ */ __name(() => import_zod.z.string().or(import
 }), "StringOrArray");
 
 // ../crouton-core/src/lib/request.model.ts
-var SortDirEnum = import_zod2.z.enum([
+var SortDirEnum = import_zod3.z.enum([
   "asc",
   "desc"
 ]);
-var RequestSchema = import_zod2.z.object({
+var RequestSchema = import_zod3.z.object({
   page: PositiveRequestNumber().optional().default(1),
   pageSize: PositiveRequestNumber().optional().default(20),
-  sort: import_zod2.z.string().optional().default("id"),
+  sort: import_zod3.z.string().optional().default("id"),
   sortDir: SortDirEnum.optional().default("asc"),
   // Filter is of the format key:value:operator (e.g. name:john:eq) operator is optional
   filter: StringOrArray().optional().default([])
@@ -115,18 +143,18 @@ var buildSortKey = /* @__PURE__ */ __name((keys, sortDir) => {
 }, "buildSortKey");
 
 // ../crouton-core/src/lib/response.model.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var ResponseRequestSchema = RequestSchema.extend({
   count: PositiveRequestNumber(),
   totalPages: PositiveRequestNumber()
 });
-var ResponseSchema = import_zod4.z.object({
-  data: import_zod4.z.array(import_zod4.z.unknown()),
+var ResponseSchema = import_zod5.z.object({
+  data: import_zod5.z.array(import_zod5.z.unknown()),
   request: ResponseRequestSchema
 });
 
 // ../crouton-core/src/lib/create-schema.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // ../crouton-core/src/lib/layout/base.builder.ts
 var Builder = class {
@@ -384,23 +412,6 @@ var LayoutBuilder = class _LayoutBuilder extends BuilderWithElements {
   }
 };
 
-// ../crouton-core/src/lib/json-config.types.ts
-var labelFromId = /* @__PURE__ */ __name((id) => {
-  const words = id.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
-  return words.charAt(0).toUpperCase() + words.slice(1).toLowerCase();
-}, "labelFromId");
-var normalizeColumns = /* @__PURE__ */ __name((columns) => {
-  if (!columns) return void 0;
-  const raw = Array.isArray(columns) ? columns : Object.entries(columns).map(([id, col]) => ({
-    id,
-    ...col
-  }));
-  return raw.map((col) => ({
-    ...col,
-    label: col.label ?? labelFromId(col.id)
-  }));
-}, "normalizeColumns");
-
 // ../crouton-core/src/lib/value-label.ts
 var wrapOne = /* @__PURE__ */ __name((value, values) => {
   const match = values.find((o) => o.value === value);
@@ -494,6 +505,515 @@ var TableBuilder = class _TableBuilder {
   }
 };
 
+// ../crouton-core/src/lib/data-source/DataSourceSchema.ts
+var import_zod8 = __toESM(require("zod"), 1);
+var DataSourceShape = import_zod8.default.object({
+  /** Datasource name (folder + `name` in data-source.json). */
+  name: import_zod8.default.string(),
+  /** Env var holding the connection URL. */
+  urlEnv: import_zod8.default.string(),
+  /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
+  generatedTypesImport: import_zod8.default.string().optional(),
+  /** Datasource type tag. Default `postgres`. */
+  type: import_zod8.default.string().default("postgres"),
+  /** Mark this as the default datasource. Default `false`. */
+  default: import_zod8.default.boolean().default(false),
+  /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
+  prismaSchema: import_zod8.default.string().optional(),
+  /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
+  prismaConfig: import_zod8.default.string().optional(),
+  /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
+  zodOutput: import_zod8.default.string().optional(),
+  /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
+  clientOutput: import_zod8.default.string().optional()
+});
+var transformDataSource = /* @__PURE__ */ __name((data) => {
+  const name = data.name ?? "name";
+  return {
+    ...data,
+    generatedTypesImport: data.generatedTypesImport ?? `@your-scope/generated/${name}`,
+    prismaSchema: data.prismaSchema ?? `prisma/${name}/schema.prisma`,
+    prismaConfig: data.prismaConfig ?? `prisma/${name}/prisma.config.ts`,
+    zodOutput: data.zodOutput ?? `generated/${name}/src`,
+    clientOutput: data.clientOutput ?? `generated/${name}/client`
+  };
+}, "transformDataSource");
+var DataSourceSchema = DataSourceShape.transform(transformDataSource);
+
+// ../crouton-core/src/lib/data-source/Operations.schema.ts
+var import_zod9 = require("zod");
+var BoolOrUpsertSchema = import_zod9.z.union([
+  import_zod9.z.boolean(),
+  import_zod9.z.object({
+    upsertOn: import_zod9.z.union([
+      import_zod9.z.string(),
+      import_zod9.z.array(import_zod9.z.string())
+    ])
+  })
+]);
+var JsonOperationsSchema = import_zod9.z.object({
+  findAll: import_zod9.z.boolean().default(true),
+  findOne: import_zod9.z.boolean().default(true),
+  create: import_zod9.z.boolean().default(true),
+  update: import_zod9.z.boolean().default(true),
+  upsert: BoolOrUpsertSchema.default(false),
+  delete: import_zod9.z.boolean().default(true)
+});
+
+// ../crouton-core/src/lib/resource/ResourceJson.schema.ts
+var import_zod16 = require("zod");
+
+// ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
+var import_zod11 = require("zod");
+
+// ../crouton-core/src/lib/resource/FieldInput.schema.ts
+var import_zod10 = require("zod");
+var RelationType = import_zod10.z.enum([
+  "oneToOne",
+  "manyToOne",
+  "oneToMany",
+  "manyToMany"
+]);
+var DetailControlSchema = import_zod10.z.object({
+  property: import_zod10.z.string(),
+  type: import_zod10.z.string().optional(),
+  options: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown()).optional(),
+  hideLabel: import_zod10.z.boolean().optional(),
+  width: import_zod10.z.string().optional()
+});
+var DetailConfigSchema = import_zod10.z.object({
+  layout: import_zod10.z.enum([
+    "collapse",
+    "row"
+  ]),
+  titleKey: import_zod10.z.string().optional(),
+  controls: import_zod10.z.array(DetailControlSchema)
+});
+var RelationFieldInputOptionsSchema = import_zod10.z.object({
+  /** Field to sort related records by, e.g. `"title"` or `"author.name"`. */
+  sort: import_zod10.z.string().optional(),
+  /** Sort direction. Defaults to `"asc"` when omitted. */
+  sortDir: import_zod10.z.enum([
+    "asc",
+    "desc"
+  ]).optional(),
+  /** CSS flex direction for the relation control button layout. */
+  direction: import_zod10.z.string().optional(),
+  /** Key used as the display label in the relation control. */
+  displayKey: import_zod10.z.string().optional(),
+  /** Path to the related resource (resolved to a URI at load time). */
+  resource: import_zod10.z.string().optional()
+}).catchall(import_zod10.z.unknown());
+var FieldInputSchema = import_zod10.z.object({
+  type: import_zod10.z.string().optional(),
+  customRender: import_zod10.z.string().optional(),
+  /**
+  * Render format hint for the frontend (e.g. `"relation"` for sub-resource
+  * relations). When `format` is `"relation"`, `resource` must also be set.
+  */
+  format: import_zod10.z.string().optional(),
+  /**
+  * Relative path to the child resource definition, e.g. `"./author.resource"`.
+  * Only used when `format` is `"relation"`. Resolved at load time to inject
+  * sub-resource URIs into `options`.
+  */
+  resource: import_zod10.z.string().optional(),
+  /**
+  * Cardinality of the relation. Used by the frontend to determine the correct
+  * renderer and behaviour (e.g. single-select vs multi-select).
+  * - `manyToOne` / `oneToOne`   — single FK reference (autocomplete / relation control)
+  * - `oneToMany` / `manyToMany` — collection (sub-resource table / multi-select)
+  */
+  relationType: RelationType.optional(),
+  /** Override the display order in form views. Lower values come first. */
+  position: import_zod10.z.number().optional(),
+  options: import_zod10.z.union([
+    RelationFieldInputOptionsSchema,
+    import_zod10.z.unknown()
+  ]).optional(),
+  /** Nested array detail layout (renders via `detailFixed`). */
+  detail: DetailConfigSchema.optional()
+});
+
+// ../crouton-core/src/lib/schema/label.helper.ts
+var labelFromId = /* @__PURE__ */ __name((id) => {
+  const words = id.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1).toLowerCase();
+}, "labelFromId");
+var normalizeLabel = /* @__PURE__ */ __name((obj) => {
+  return {
+    label: labelFromId(obj.id),
+    ...obj
+  };
+}, "normalizeLabel");
+
+// ../crouton-core/src/lib/resource/CalculatedColumn.schema.ts
+var CalculatedColumnSchema = import_zod11.z.object({
+  /** Column identifier used in the response payload and UI schema. */
+  id: import_zod11.z.string(),
+  /** SQL alias — must match `id`. */
+  alias: import_zod11.z.string(),
+  /** Human-readable label shown in the table header. */
+  label: import_zod11.z.string().optional(),
+  sqlExpression: import_zod11.z.string(),
+  /** JSON schema / cast type for the computed value. Defaults to `"number"`. `"string"` skips CAST. */
+  type: import_zod11.z.enum([
+    "number",
+    "boolean",
+    "string"
+  ]).optional(),
+  /**
+   * Insertion position relative to the other visible columns.
+   * Uses the same semantics as `fieldInput.position` on regular columns:
+   * `position: N` places this column before the element currently at index N.
+   * Can also be set via `fieldInput.position` (takes precedence).
+   */
+  position: import_zod11.z.number().optional(),
+  hiddenInTable: import_zod11.z.boolean().optional(),
+  hiddenInView: import_zod11.z.boolean().optional(),
+  /**
+   * Field input options for rendering in form / view schemas.
+   * Supports `colspan`, `format`, and any other options passed to the Control renderer.
+   * `position` here takes precedence over the top-level `position`.
+   */
+  fieldInput: FieldInputSchema.optional()
+}).transform(normalizeLabel);
+
+// ../crouton-core/src/lib/resource/Column.ts
+var import_zod12 = require("zod");
+var WhenConditionSchema = import_zod12.z.object({
+  field: import_zod12.z.string(),
+  eq: import_zod12.z.unknown().optional(),
+  neq: import_zod12.z.unknown().optional(),
+  exists: import_zod12.z.boolean().optional(),
+  notExists: import_zod12.z.boolean().optional()
+});
+var JsonColumnSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  column: import_zod12.z.string().optional(),
+  label: import_zod12.z.string().optional(),
+  hiddenInTable: import_zod12.z.boolean().default(false),
+  hiddenInForm: import_zod12.z.boolean().default(false),
+  hiddenInView: import_zod12.z.boolean().default(false),
+  sortable: import_zod12.z.boolean().default(false),
+  defaultSort: import_zod12.z.boolean().default(false),
+  searchable: import_zod12.z.boolean().default(false),
+  filterable: import_zod12.z.boolean().default(false),
+  createable: import_zod12.z.boolean().default(true),
+  updateable: import_zod12.z.boolean().default(true),
+  hideLabel: import_zod12.z.boolean().default(false),
+  showWhen: WhenConditionSchema.optional(),
+  hideWhen: WhenConditionSchema.optional(),
+  disabledWhen: WhenConditionSchema.optional(),
+  displayKey: import_zod12.z.string().optional(),
+  sortId: import_zod12.z.string().optional(),
+  /**
+  * Name of a shared enum in the project enum registry (`crouton.enums.json`).
+  * At load time the loader injects that enum's `{ value, label }[]` into
+  * `fieldInput.options.values`, so columns don't duplicate the option list.
+  */
+  enum: import_zod12.z.string().optional(),
+  idField: import_zod12.z.boolean().default(false),
+  showInLookup: import_zod12.z.boolean().default(false),
+  columnType: import_zod12.z.string().default("string"),
+  fieldInput: FieldInputSchema.optional(),
+  /**
+  * Path to another `resource.json` whose columns are expanded as nested sub-columns
+  * under this column's object key.
+  *
+  * Example: `"extend": "../internalAuthor/resource.json"` on a column `author`
+  * auto-generates virtual sub-columns like `author_name` (column: "author", displayKey: "name").
+  *
+  * Visibility (`hiddenInTable/Form/View`) on this column is inherited by all sub-columns as a
+  * default; the referenced resource's own column visibility further restricts it.
+  */
+  extend: import_zod12.z.string().optional(),
+  /**
+  * Per-sub-column overrides when using `extend`.
+  * Key: the virtual column id (`"{extendId}_{refColId}"`) or just the referenced column id.
+  * Value: any `JsonColumn` fields to merge over the generated virtual column.
+  */
+  columns: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())).optional()
+});
+
+// ../crouton-core/src/lib/resource/Sidebar.schema.ts
+var import_zod13 = __toESM(require("zod"), 1);
+var SidebarGroupSchema2 = import_zod13.default.object({
+  /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
+  label: import_zod13.default.string().optional(),
+  /** Controls the order of this group among top-level sidebar items. */
+  position: import_zod13.default.string().optional()
+});
+var SidebarSchema = import_zod13.default.object({
+  hide: import_zod13.default.boolean().default(false),
+  position: import_zod13.default.number().optional(),
+  label: import_zod13.default.string().optional(),
+  /**
+  * Slug of the group this resource belongs to.
+  * Must match a key in `sidebarGroups` in `crouton.json`.
+  * Resources with the same `group` are nested under a shared collapsible section.
+  */
+  group: import_zod13.default.string().optional()
+});
+
+// ../crouton-core/src/lib/resource/TableAction.schema.ts
+var import_zod14 = require("zod");
+var ActionConditionSchema = import_zod14.z.object({
+  /** Row field to evaluate. */
+  field: import_zod14.z.string(),
+  /**
+  * Comparison operator. Defaults to `"eq"`.
+  * - `eq` / `neq`         — strict equality
+  * - `gt` / `gte` / `lt` / `lte` — numeric or date comparison
+  * - `exists`             — field is not null / undefined / empty string
+  * - `notExists`          — field is null / undefined / empty string
+  */
+  op: import_zod14.z.enum([
+    "eq",
+    "neq",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "exists",
+    "notExists"
+  ]).default("eq"),
+  /** Comparison value. Not required for `exists` / `notExists`. */
+  value: import_zod14.z.unknown().optional()
+});
+var ActionSchema = import_zod14.z.object({
+  type: import_zod14.z.string(),
+  /** Unique identifier for the action. */
+  id: import_zod14.z.string(),
+  /** Human-readable button label. */
+  label: import_zod14.z.string(),
+  /** MDI icon name, e.g. `"mdi:open-in-new"`. */
+  icon: import_zod14.z.string().optional(),
+  /** Tooltip text. Falls back to `label` when omitted. */
+  tooltip: import_zod14.z.string().optional(),
+  condition: ActionConditionSchema.optional()
+});
+var JsonProcedureActionSchema = ActionSchema.extend({
+  type: import_zod14.z.literal("procedure").default("procedure"),
+  /**
+  * Filename (without extension) inside the resource's `actions/` directory
+  * that exports the table-action procedure, e.g. `"syncZotero"`.
+  */
+  procedure: import_zod14.z.string(),
+  /** HTTP method for the frontend. Defaults to `"post"`. */
+  method: import_zod14.z.string().optional().default("post"),
+  /** Static query / body params passed to the endpoint. */
+  data: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional()
+});
+var JsonLinkActionSchema = ActionSchema.extend({
+  /** Optional condition evaluated per row. Button is hidden when the condition is false. */
+  type: import_zod14.z.literal("link").default("link"),
+  /** URL to open. May contain `{env.VAR}` placeholders. */
+  href: import_zod14.z.string()
+});
+var transformAction = /* @__PURE__ */ __name((action) => {
+  const label = action.label;
+  return {
+    tooltip: label,
+    ...action
+  };
+}, "transformAction");
+var JsonActionSchema = import_zod14.z.union([
+  JsonProcedureActionSchema,
+  JsonLinkActionSchema
+]).transform(transformAction);
+
+// ../crouton-core/src/lib/resource/include.schema.ts
+var import_zod15 = require("zod");
+var JsonIncludeEntrySchema = import_zod15.z.lazy(() => import_zod15.z.union([
+  import_zod15.z.string(),
+  import_zod15.z.object({
+    relation: import_zod15.z.string(),
+    include: import_zod15.z.array(JsonIncludeEntrySchema).optional(),
+    /** Prisma-format orderBy clause applied to the included records. */
+    orderBy: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional()
+  })
+]));
+
+// ../crouton-core/src/lib/resource/ResourceJson.schema.ts
+var JsonColumnsMapSchema = import_zod16.z.record(import_zod16.z.string(), JsonColumnSchema.omit({
+  id: true
+}).catchall(import_zod16.z.unknown()));
+var ColumnsSchema = JsonColumnsMapSchema;
+var JsonDisplaySchema = import_zod16.z.object({
+  mode: import_zod16.z.enum([
+    "page",
+    "modal"
+  ]).default("modal"),
+  customComponent: import_zod16.z.string().nullable().optional().default(null)
+});
+var normalizeColumns = /* @__PURE__ */ __name((columns) => {
+  if (!columns) return void 0;
+  const raw = Array.isArray(columns) ? columns : Object.entries(columns).map(([id, col]) => ({
+    id,
+    ...col
+  }));
+  return raw.map((col) => ({
+    ...col,
+    label: col.label ?? labelFromId(col.id)
+  }));
+}, "normalizeColumns");
+var ResourceJsonShape = import_zod16.z.object({
+  name: import_zod16.z.string(),
+  route: import_zod16.z.string(),
+  model: import_zod16.z.string(),
+  tag: import_zod16.z.string(),
+  title: import_zod16.z.string().optional(),
+  table: import_zod16.z.string().optional(),
+  database: import_zod16.z.string().optional(),
+  sidebar: SidebarSchema.default(SidebarSchema.parse({})),
+  display: JsonDisplaySchema.default(JsonDisplaySchema.parse({})),
+  operations: JsonOperationsSchema,
+  columns: ColumnsSchema.default(ColumnsSchema.parse({})),
+  calculatedColumns: import_zod16.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod16.z.array(JsonActionSchema).default([]),
+  /** Global table-level actions (no record id). Shown as toolbar buttons. */
+  tableActions: import_zod16.z.array(JsonActionSchema).default([]),
+  /** Modal width when opening a form for this resource. */
+  modalSize: import_zod16.z.enum([
+    "xs",
+    "sm",
+    "lg",
+    "xl"
+  ]).default("sm"),
+  /**
+  * Relations to include when querying this resource.
+  * Each entry is either a plain relation name (`"author"` → `include: { author: true }`)
+  * or an object for nested includes:
+  * `{ "relation": "text_author", "include": ["author"] }` →
+  *   `include: { text_author: { include: { author: true } } }`
+  */
+  include: import_zod16.z.array(JsonIncludeEntrySchema).default([])
+});
+var ResourceJsonSchema = ResourceJsonShape.transform((obj) => {
+  const title = obj.title ?? labelFromId(obj.name);
+  return {
+    title,
+    ...obj,
+    columns: normalizeColumns(obj.columns)
+  };
+});
+
+// ../crouton-core/src/lib/config/CroutonConfig.schema.ts
+var import_zod17 = require("zod");
+var RulesetSchema = import_zod17.z.object({
+  hideIdInTable: import_zod17.z.boolean().default(true),
+  hideIdInForm: import_zod17.z.boolean().default(true),
+  hideIdInView: import_zod17.z.boolean().default(true),
+  hideTimestamps: import_zod17.z.boolean().default(true),
+  hideForeignKeys: import_zod17.z.boolean().default(true),
+  includeRelations: import_zod17.z.boolean().default(false),
+  hideRelationsInTable: import_zod17.z.boolean().default(true),
+  showRelationsInForm: import_zod17.z.boolean().default(true),
+  enumValueLabel: import_zod17.z.boolean().default(true),
+  sharedEnums: import_zod17.z.boolean().default(true),
+  defaultOperations: JsonOperationsSchema.default(JsonOperationsSchema.parse({}))
+});
+var CroutonConfigSchema = import_zod17.z.object({
+  /**
+  * Application title served to the frontend via `GET /_app/layout`.
+  * Displayed in the admin sidebar header.
+  */
+  title: import_zod17.z.string(),
+  /** Where resource directories live, relative to the project root. */
+  resourcesDir: import_zod17.z.string(),
+  /** Where datasource folders live (each with a `data-source.json`). */
+  dataSourcesDir: import_zod17.z.string(),
+  /**
+  * Template for a model's Zod export name. `{Model}` → Prisma model name.
+  * Defaults to `{Model}WithRelationsSchema` (the relations-aware schema
+  * emitted by zod-prisma-types when `createRelationValuesTypes` is on).
+  */
+  schemaExportName: import_zod17.z.string().default("{Model}WithRelationsSchema"),
+  /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
+  enumsFile: import_zod17.z.string().default("croutons.enums.json"),
+  /** Optional overrides of the default visibility ruleset. */
+  rules: RulesetSchema.default(RulesetSchema.parse({})),
+  /**
+  * Sidebar group definitions, keyed by group slug (e.g. `"metadata"`).
+  * Resources reference a group via `sidebar.group` in their `resource.json`.
+  */
+  sidebarGroups: import_zod17.z.record(import_zod17.z.string(), SidebarGroupSchema2).default({}),
+  /**
+  * Whether form fields are saved automatically as the user edits them.
+  * @default true
+  */
+  autoSave: import_zod17.z.boolean().default(true)
+});
+
+// ../crouton-core/src/lib/config/readConfig.ts
+var CONFIG_FILES = [
+  "crouton.json",
+  "crouton.mjs",
+  "crouton.js"
+];
+
+// src/lib/crud/app-layout/app-layout.builder.ts
+var byPosition = /* @__PURE__ */ __name((a, b) => {
+  if (a.position != null && b.position != null) return a.position - b.position;
+  if (a.position != null) return -1;
+  if (b.position != null) return 1;
+  return a.label.localeCompare(b.label);
+}, "byPosition");
+var buildLayoutPayload = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true) => {
+  const visible = configs.filter((c) => c.sidebar?.hide !== true && c.views?.["table"]);
+  const topLevel = [];
+  const groupMap = new Map(Object.entries(sidebarGroups).map(([slug, cfg]) => [
+    slug,
+    {
+      label: cfg.label ?? labelFromId(slug),
+      position: cfg.position,
+      children: []
+    }
+  ]));
+  for (const c of visible) {
+    const leaf = SidebarLeafSchema.parse({
+      id: c.name,
+      label: c.sidebar?.label ?? c.title ?? c.tag,
+      position: c.sidebar?.position
+    });
+    const groupSlug = c.sidebar?.group;
+    if (groupSlug) {
+      if (!groupMap.has(groupSlug)) {
+        groupMap.set(groupSlug, {
+          label: labelFromId(groupSlug),
+          children: []
+        });
+      }
+      groupMap.get(groupSlug).children.push(leaf);
+    } else {
+      topLevel.push(leaf);
+    }
+  }
+  const groups = [
+    ...groupMap.entries()
+  ].filter(([, g]) => g.children.length > 0).map(([id, g]) => ({
+    kind: "group",
+    id,
+    label: g.label,
+    position: g.position,
+    children: g.children.sort(byPosition)
+  }));
+  const sidebar = [
+    ...topLevel,
+    ...groups
+  ].sort(byPosition);
+  return {
+    sidebar,
+    title,
+    autoSave
+  };
+}, "buildLayoutPayload");
+
+// src/lib/crud/app-layout/app-layout.controller.ts
+var import_common2 = require("@nestjs/common");
+var import_swagger = require("@nestjs/swagger");
+
 // src/lib/crud/dev-mode.ts
 var IS_DEV = process.env["NODE_ENV"] !== "production";
 
@@ -542,7 +1062,7 @@ ResourceConfigRegistry = _ts_decorate([
   ])
 ], ResourceConfigRegistry);
 
-// src/lib/crud/app-layout.controller.ts
+// src/lib/crud/app-layout/app-layout.controller.ts
 function _ts_decorate2(decorators, target, key, desc2) {
   var c = arguments.length, r = c < 3 ? target : desc2 === null ? desc2 = Object.getOwnPropertyDescriptor(target, key) : desc2, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc2);
@@ -554,62 +1074,6 @@ function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata2, "_ts_metadata");
-var byPosition = /* @__PURE__ */ __name((a, b) => {
-  if (a.position != null && b.position != null) return a.position - b.position;
-  if (a.position != null) return -1;
-  if (b.position != null) return 1;
-  return a.label.localeCompare(b.label);
-}, "byPosition");
-var buildLayoutPayload = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true) => {
-  const visible = configs.filter((c) => c.sidebar?.hide !== true && c.views?.["table"]);
-  const topLevel = [];
-  const groupMap = new Map(Object.entries(sidebarGroups).map(([slug, cfg]) => [
-    slug,
-    {
-      label: cfg.label ?? labelFromId(slug),
-      position: cfg.position,
-      children: []
-    }
-  ]));
-  for (const c of visible) {
-    const leaf = {
-      kind: "item",
-      id: c.name,
-      label: c.sidebar?.label ?? c.title ?? c.tag,
-      position: c.sidebar?.position
-    };
-    const groupSlug = c.sidebar?.group;
-    if (groupSlug) {
-      if (!groupMap.has(groupSlug)) {
-        groupMap.set(groupSlug, {
-          label: labelFromId(groupSlug),
-          children: []
-        });
-      }
-      groupMap.get(groupSlug).children.push(leaf);
-    } else {
-      topLevel.push(leaf);
-    }
-  }
-  const groups = [
-    ...groupMap.entries()
-  ].filter(([, g]) => g.children.length > 0).map(([id, g]) => ({
-    kind: "group",
-    id,
-    label: g.label,
-    position: g.position,
-    children: g.children.sort(byPosition)
-  }));
-  const sidebar = [
-    ...topLevel,
-    ...groups
-  ].sort(byPosition);
-  return {
-    sidebar,
-    title,
-    autoSave
-  };
-}, "buildLayoutPayload");
 var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups = {}, title, autoSave = true) => {
   const layoutPayload = buildLayoutPayload(configs, sidebarGroups, title, autoSave);
   let AppLayoutController = class AppLayoutController {
@@ -655,6 +1119,45 @@ var createAppLayoutController = /* @__PURE__ */ __name((configs, sidebarGroups =
   return AppLayoutController;
 }, "createAppLayoutController");
 
+// src/lib/crud/config/read.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var fileExists = /* @__PURE__ */ __name(async (p) => {
+  try {
+    await (0, import_promises.access)(p);
+    return true;
+  } catch {
+    return false;
+  }
+}, "fileExists");
+var findConfigPath = /* @__PURE__ */ __name(async (cwd) => {
+  let dir = (0, import_node_path.resolve)(cwd);
+  while (true) {
+    for (const name of CONFIG_FILES) {
+      const candidate = (0, import_node_path.join)(dir, name);
+      if (await fileExists(candidate)) return candidate;
+    }
+    const parent = (0, import_node_path.dirname)(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}, "findConfigPath");
+var loadConfig = /* @__PURE__ */ __name(async () => {
+  const cwd = (0, import_node_path.resolve)(process.cwd());
+  const path = await findConfigPath(cwd);
+  if (!path) {
+    throw new Error(`No crouton config found (looked for ${CONFIG_FILES.join(", ")} up from ${cwd}).`);
+  }
+  let config;
+  if (path.endsWith(".json")) {
+    config = JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+  } else {
+    const mod = await import(path);
+    config = mod.default ?? mod;
+  }
+  return CroutonConfigSchema.parse(config);
+}, "loadConfig");
+
 // src/lib/crud/crouton-validation.filter.ts
 var import_common3 = require("@nestjs/common");
 
@@ -697,25 +1200,158 @@ CroutonValidationExceptionFilter = _ts_decorate3([
 
 // src/lib/crud/crud-controller.factory.ts
 var import_common11 = require("@nestjs/common");
-var import_common12 = require("@nestjs/common");
 var import_swagger6 = require("@nestjs/swagger");
 
-// src/lib/crud/crud.config.ts
-var resolveDefinition = /* @__PURE__ */ __name((config) => {
-  const def2 = config.definition;
-  return typeof def2 === "function" ? def2() : def2;
-}, "resolveDefinition");
-var isOperationEnabled = /* @__PURE__ */ __name((def2, op) => def2[op] != null, "isOperationEnabled");
-var schemaFor = /* @__PURE__ */ __name((def2, op) => {
-  const entry = def2[op];
-  if (!entry || entry === true) return void 0;
-  return entry.schema;
-}, "schemaFor");
-var upsertOnFor = /* @__PURE__ */ __name((def2) => def2.upsert?.upsertOn, "upsertOnFor");
-
-// src/lib/crud/read.repository.ts
-var import_common4 = require("@nestjs/common");
-
+// src/lib/crud/action/action.types.ts
+var import_zod18 = require("zod");
+var ActionMetadataSchema = import_zod18.z.object({
+  /** URL segment used in the endpoint. */
+  id: import_zod18.z.string(),
+  /** Human-readable label shown as a button. */
+  label: import_zod18.z.string().optional(),
+  /** MDI icon name, e.g. `"mdi:open-in-new"`. */
+  icon: import_zod18.z.string().optional(),
+  /** Tooltip text. Falls back to `label` when omitted. */
+  tooltip: import_zod18.z.string().optional(),
+  /** Per-row condition — button is hidden when false. */
+  condition: import_zod18.z.custom().optional()
+});
+var ResourceLinkActionSchema = ActionMetadataSchema.extend({
+  type: import_zod18.z.literal("link"),
+  /** URL to open. May contain `{id}` or `{env.VAR}` placeholders. */
+  href: import_zod18.z.string()
+});
+var ResourceRowProcedureActionSchema = ActionMetadataSchema.extend({
+  type: import_zod18.z.literal("procedure").optional(),
+  /** HTTP method for the endpoint. Defaults to `"post"`. */
+  method: import_zod18.z.string().optional(),
+  /** Static data payload merged into the request body by the frontend. */
+  data: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional(),
+  /** Procedure called with `(prisma, recordId)`. */
+  procedure: import_zod18.z.custom((v) => typeof v === "function")
+});
+var ResourceTableProcedureActionSchema = ActionMetadataSchema.extend({
+  type: import_zod18.z.literal("procedure").optional(),
+  /** HTTP method for the endpoint. Defaults to `"post"`. */
+  method: import_zod18.z.string().optional(),
+  /** Static data payload merged into the request body by the frontend. */
+  data: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown()).optional(),
+  /** Procedure called with `(prisma)` — no record id. */
+  procedure: import_zod18.z.custom((v) => typeof v === "function")
+});
+var ResourceRowActionSchema = import_zod18.z.union([
+  ResourceRowProcedureActionSchema,
+  ResourceLinkActionSchema
+]);
+var ResourceTableActionSchema = import_zod18.z.union([
+  ResourceTableProcedureActionSchema,
+  ResourceLinkActionSchema
+]);
+var isRowProcedureAction = /* @__PURE__ */ __name((action) => action.type !== "link", "isRowProcedureAction");
+var isTableProcedureAction = /* @__PURE__ */ __name((action) => action.type !== "link", "isTableProcedureAction");
+
+// src/lib/crud/loader/module.loader.ts
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_node_path2 = require("path");
+var import_meta = {};
+var _require = (0, import_node_module.createRequire)(import_meta.url ?? __filename);
+var findModule = /* @__PURE__ */ __name((dir, name) => {
+  for (const ext of [
+    ".ts",
+    ".js"
+  ]) {
+    const p = (0, import_node_path2.join)(dir, `${name}${ext}`);
+    if ((0, import_node_fs.existsSync)(p)) return p;
+  }
+  return void 0;
+}, "findModule");
+var IS_VITE = typeof globalThis.__vite_ssr_import__ === "function";
+var importDefault = /* @__PURE__ */ __name(async (filePath) => {
+  try {
+    if (IS_VITE) {
+      const importPath = IS_DEV ? `${filePath}?t=${Date.now()}` : filePath;
+      const mod = await import(importPath);
+      return mod.default ?? mod;
+    } else {
+      const mod = _require(filePath);
+      return mod.default;
+    }
+  } catch {
+    return void 0;
+  }
+}, "importDefault");
+
+// src/lib/crud/action/action.loader.ts
+var import_node_path3 = require("path");
+var loadActions = /* @__PURE__ */ __name(async (jsonActions, basePath, scope) => {
+  const tag = scope === "row" ? "actions" : "tableActions";
+  const results = [];
+  for (const action of jsonActions) {
+    if (action.type === "link") {
+      results.push({
+        type: "link",
+        id: action.id,
+        label: action.label,
+        href: action.href,
+        ...action.icon && {
+          icon: action.icon
+        },
+        ...action.tooltip && {
+          tooltip: action.tooltip
+        },
+        ...action.condition && {
+          condition: action.condition
+        }
+      });
+      continue;
+    }
+    const file = findModule((0, import_node_path3.join)(basePath, "actions"), action.procedure);
+    if (!file) {
+      console.warn(`[${tag}] Procedure file not found for "${action.id}" in ${basePath}/actions/`);
+      continue;
+    }
+    const mod = await importDefault(file);
+    if (!mod) {
+      console.warn(`[${tag}] No default export in ${file}`);
+      continue;
+    }
+    results.push({
+      id: action.id,
+      label: action.label,
+      method: action.method,
+      data: action.data,
+      ...action.icon && {
+        icon: action.icon
+      },
+      ...action.tooltip && {
+        tooltip: action.tooltip
+      },
+      ...action.condition && {
+        condition: action.condition
+      },
+      procedure: mod
+    });
+  }
+  return results;
+}, "loadActions");
+
+// src/lib/crud/crud.config.ts
+var resolveDefinition = /* @__PURE__ */ __name((config) => {
+  const def2 = config.definition;
+  return typeof def2 === "function" ? def2() : def2;
+}, "resolveDefinition");
+var isOperationEnabled = /* @__PURE__ */ __name((def2, op) => def2[op] != null, "isOperationEnabled");
+var schemaFor = /* @__PURE__ */ __name((def2, op) => {
+  const entry = def2[op];
+  if (!entry || entry === true) return void 0;
+  return entry.schema;
+}, "schemaFor");
+var upsertOnFor = /* @__PURE__ */ __name((def2) => def2.upsert?.upsertOn, "upsertOnFor");
+
+// src/lib/crud/read.repository.ts
+var import_common4 = require("@nestjs/common");
+
 // src/lib/crud/sql.helpers.ts
 var castExpression = /* @__PURE__ */ __name((col) => {
   if (col.type === "string") return `(${col.sqlExpression})`;
@@ -1199,9 +1835,9 @@ var ReadRepository = class {
 };
 
 // src/lib/crud/schema.utils.ts
-var import_zod7 = require("zod");
+var import_zod19 = require("zod");
 var dateOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
-  if (zodSchema instanceof import_zod7.z.ZodDate) {
+  if (zodSchema instanceof import_zod19.z.ZodDate) {
     jsonSchema.type = "string";
     jsonSchema.format = "date-time";
   }
@@ -1211,7 +1847,7 @@ var jsonSchemaOpts = {
   override: dateOverride
 };
 function isZodSchema(schema) {
-  return schema instanceof import_zod7.ZodObject;
+  return schema instanceof import_zod19.ZodObject;
 }
 __name(isZodSchema, "isZodSchema");
 var isNullableProperty = /* @__PURE__ */ __name((property) => {
@@ -1225,7 +1861,7 @@ var dropNullableFromRequired = /* @__PURE__ */ __name((jsonSchema) => {
 }, "dropNullableFromRequired");
 function toJsonSchema(schema) {
   if (isZodSchema(schema)) {
-    const jsonSchema = (0, import_zod7.toJSONSchema)(schema, {
+    const jsonSchema = (0, import_zod19.toJSONSchema)(schema, {
       target: "openApi3",
       ...jsonSchemaOpts
     });
@@ -1600,21 +2236,27 @@ DataSourceRegistry = _ts_decorate4([
 ], DataSourceRegistry);
 
 // src/lib/crud/data-source/data-source.loader.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_fs2 = require("fs");
+var import_node_path4 = require("path");
 var loadDataSourcesFromDir = /* @__PURE__ */ __name(async (dirPath) => {
-  if (!(0, import_node_fs.existsSync)(dirPath)) return [];
-  const entries = (0, import_node_fs.readdirSync)(dirPath, {
+  if (!(0, import_node_fs2.existsSync)(dirPath)) return [];
+  const entries = (0, import_node_fs2.readdirSync)(dirPath, {
     withFileTypes: true
   });
   const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   const results = [];
   for (const dir of dirs) {
-    const basePath = (0, import_node_path.join)(dirPath, dir);
-    const jsonFile = (0, import_node_path.join)(basePath, "data-source.json");
-    if (!(0, import_node_fs.existsSync)(jsonFile)) continue;
-    const config = JSON.parse((0, import_node_fs.readFileSync)(jsonFile, "utf-8"));
-    const indexFile = findModule(basePath, "index");
+    const basePath = (0, import_node_path4.join)(dirPath, dir);
+    const jsonFile = (0, import_node_path4.join)(basePath, "data-source.json");
+    if (!(0, import_node_fs2.existsSync)(jsonFile)) continue;
+    const _config = JSON.parse((0, import_node_fs2.readFileSync)(jsonFile, "utf-8"));
+    const datasource = DataSourceSchema.safeParse(_config);
+    if (!datasource.success) {
+      console.error(datasource.error);
+      throw new Error(`Invalid datasource schema: ${jsonFile}`);
+    }
+    const config = datasource.data;
+    const indexFile = findModule2(basePath, "index");
     if (!indexFile) continue;
     const mod = await import(indexFile);
     const client = mod.default;
@@ -1626,13 +2268,13 @@ var loadDataSourcesFromDir = /* @__PURE__ */ __name(async (dirPath) => {
   }
   return results;
 }, "loadDataSourcesFromDir");
-var findModule = /* @__PURE__ */ __name((dir, name) => {
+var findModule2 = /* @__PURE__ */ __name((dir, name) => {
   for (const ext of [
     ".ts",
     ".js"
   ]) {
-    const p = (0, import_node_path.join)(dir, `${name}${ext}`);
-    if ((0, import_node_fs.existsSync)(p)) return p;
+    const p = (0, import_node_path4.join)(dir, `${name}${ext}`);
+    if ((0, import_node_fs2.existsSync)(p)) return p;
   }
   return void 0;
 }, "findModule");
@@ -1655,7 +2297,7 @@ var desc = /* @__PURE__ */ __name((cls, method) => Object.getOwnPropertyDescript
 var registerActionRoutes = /* @__PURE__ */ __name((ctx) => {
   const { cls, config } = ctx;
   const { name } = config;
-  const procedureActions = (config.actions ?? []).filter((a) => a.type !== "link");
+  const procedureActions = (config.actions ?? []).filter(isRowProcedureAction);
   for (const action of procedureActions) {
     const methodName = `procedure_${action.id}`;
     def(cls, methodName, async function(recordId) {
@@ -1680,7 +2322,7 @@ var registerActionRoutes = /* @__PURE__ */ __name((ctx) => {
 var registerTableActionRoutes = /* @__PURE__ */ __name((ctx) => {
   const { cls, config } = ctx;
   const { name } = config;
-  const procedureActions = (config.tableActions ?? []).filter((a) => a.type !== "link");
+  const procedureActions = (config.tableActions ?? []).filter(isTableProcedureAction);
   for (const action of procedureActions) {
     const methodName = `tableAction_${action.id}`;
     def(cls, methodName, async function() {
@@ -1782,38 +2424,56 @@ var ZodValidationPipe = class {
 };
 
 // src/lib/crud/operations/register-crud.ts
+var findAll = /* @__PURE__ */ __name(async (repo, params, q, lookupLabel) => {
+  const effectiveParams = {
+    ...params
+  };
+  if (q && lookupLabel) {
+    effectiveParams.filter = [
+      ...params.filter ?? [],
+      `${lookupLabel}:${q}`
+    ];
+  }
+  const [data, count] = await Promise.all([
+    repo.findAll(effectiveParams),
+    repo.count(effectiveParams.filter)
+  ]);
+  const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
+  return {
+    data,
+    request: {
+      count,
+      page: params.page,
+      pageSize: params.pageSize,
+      totalPages,
+      sort: params.sort,
+      sortDir: params.sortDir,
+      filter: params.filter
+    }
+  };
+}, "findAll");
+var findOne = /* @__PURE__ */ __name(async (repo, id) => {
+  return repo.findOne(id);
+}, "findOne");
+var create = /* @__PURE__ */ __name(async (repo, body) => {
+  return repo.create(body);
+}, "create");
+var update = /* @__PURE__ */ __name(async (repo, id, body) => {
+  return repo.update(id, body);
+}, "update");
+var upsert = /* @__PURE__ */ __name(async (repo, body) => {
+  return repo.upsert(body);
+}, "upsert");
+var del = /* @__PURE__ */ __name(async (repo, id) => {
+  return repo.delete(id);
+}, "del");
 var registerFindAll = /* @__PURE__ */ __name((ctx) => {
   if (!isOperationEnabled(ctx.definition, "findAll")) return;
   const { cls, config, listSchema } = ctx;
   const { name } = config;
   const lookupLabel = config.lookup?.label;
   def(cls, "findAll", async function(params, q) {
-    const effectiveParams = {
-      ...params
-    };
-    if (q && lookupLabel) {
-      effectiveParams.filter = [
-        ...params.filter ?? [],
-        `${lookupLabel}:${q}`
-      ];
-    }
-    const [data, count] = await Promise.all([
-      this.repo.findAll(effectiveParams),
-      this.repo.count(effectiveParams.filter)
-    ]);
-    const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
-    return {
-      data,
-      request: {
-        count,
-        page: params.page,
-        pageSize: params.pageSize,
-        totalPages,
-        sort: params.sort,
-        sortDir: params.sortDir,
-        filter: params.filter
-      }
-    };
+    return findAll(this.repo, params, q, lookupLabel);
   });
   const d = desc(cls, "findAll");
   (0, import_common8.Get)()(cls.prototype, "findAll", d);
@@ -1838,7 +2498,7 @@ var registerFindOne = /* @__PURE__ */ __name((ctx) => {
   const { cls, config, oneSchema, idParamMeta } = ctx;
   const { name } = config;
   def(cls, "findOne", function(id) {
-    return this.repo.findOne(id);
+    return findOne(this.repo, id);
   });
   const d = desc(cls, "findOne");
   (0, import_common8.Get)(":id")(cls.prototype, "findOne", d);
@@ -1863,7 +2523,7 @@ var registerCreate = /* @__PURE__ */ __name((ctx) => {
   const { cls, config, createSchema, bodyDecorator } = ctx;
   const { name } = config;
   def(cls, "create", function(body) {
-    return this.repo.create(body);
+    return create(this.repo, body);
   });
   const d = desc(cls, "create");
   (0, import_common8.Post)()(cls.prototype, "create", d);
@@ -1886,7 +2546,7 @@ var registerUpdate = /* @__PURE__ */ __name((ctx) => {
   const { cls, config, updateSchema, idParamMeta, bodyDecorator } = ctx;
   const { name } = config;
   def(cls, "update", function(id, body) {
-    return this.repo.update(id, body);
+    return update(this.repo, id, body);
   });
   const d = desc(cls, "update");
   (0, import_common8.Patch)(":id")(cls.prototype, "update", d);
@@ -1912,7 +2572,7 @@ var registerUpsert = /* @__PURE__ */ __name((ctx) => {
   const { cls, config, upsertSchema, bodyDecorator } = ctx;
   const { name } = config;
   def(cls, "upsert", function(body) {
-    return this.repo.upsert(body);
+    return upsert(this.repo, body);
   });
   const d = desc(cls, "upsert");
   (0, import_common8.Put)()(cls.prototype, "upsert", d);
@@ -1935,7 +2595,7 @@ var registerDelete = /* @__PURE__ */ __name((ctx) => {
   const { cls, config, idParamMeta } = ctx;
   const { name } = config;
   def(cls, "delete", function(id) {
-    return this.repo.delete(id);
+    return del(this.repo, id);
   });
   const d = desc(cls, "delete");
   (0, import_common8.Delete)(":id")(cls.prototype, "delete", d);
@@ -2124,6 +2784,12 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
         id: a.id,
         label: a.label,
         href: resolveEnvPlaceholders(a.href),
+        ...a.icon && {
+          icon: a.icon
+        },
+        ...a.tooltip && {
+          tooltip: a.tooltip
+        },
         ...a.condition && {
           condition: a.condition
         }
@@ -2135,6 +2801,12 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
         ...a.data && {
           data: a.data
         },
+        ...a.icon && {
+          icon: a.icon
+        },
+        ...a.tooltip && {
+          tooltip: a.tooltip
+        },
         ...a.condition && {
           condition: a.condition
         }
@@ -2147,7 +2819,10 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
         label: a.label,
         icon: a.icon,
         tooltip: a.tooltip,
-        href: resolveEnvPlaceholders(a.href)
+        href: resolveEnvPlaceholders(a.href),
+        ...a.condition && {
+          condition: a.condition
+        }
       } : {
         id: a.id,
         label: a.label,
@@ -2157,6 +2832,9 @@ var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
         method: a.method ?? "post",
         ...a.data && {
           data: a.data
+        },
+        ...a.condition && {
+          condition: a.condition
         }
       })
     }
@@ -2231,6 +2909,34 @@ var registerResourceJsonEndpoint = /* @__PURE__ */ __name((ctx) => {
 // src/lib/crud/operations/register-sub-resources.ts
 var import_common10 = require("@nestjs/common");
 var import_swagger5 = require("@nestjs/swagger");
+var findAllByParent = /* @__PURE__ */ __name(async (repo, id, childRoute, params) => {
+  const { data, count } = await repo.findAllByParent(id, childRoute, params);
+  const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
+  return {
+    data,
+    request: {
+      count,
+      page: params.page,
+      pageSize: params.pageSize,
+      totalPages,
+      sort: params.sort,
+      sortDir: params.sortDir,
+      filter: params.filter
+    }
+  };
+}, "findAllByParent");
+var createChild = /* @__PURE__ */ __name(async (repo, id, sub, body) => {
+  return repo.createChild(id, sub, body);
+}, "createChild");
+var findOneChild = /* @__PURE__ */ __name(async (repo, sub, childId, parentId) => {
+  return repo.findOneChild(sub, childId, parentId);
+}, "findOneChild");
+var updateChild = /* @__PURE__ */ __name(async (repo, sub, childId, body) => {
+  return repo.updateChild(sub, childId, body);
+}, "updateChild");
+var deleteChild = /* @__PURE__ */ __name(async (repo, sub, childId, parentId) => {
+  return repo.deleteChild(sub, childId, parentId);
+}, "deleteChild");
 var registerSubResourceSchemas = /* @__PURE__ */ __name((ctx, sub) => {
   if (!sub.views) return;
   const { cls, config, baseUrl } = ctx;
@@ -2302,20 +3008,7 @@ var registerSubResourceFindAll = /* @__PURE__ */ __name((ctx, sub) => {
   const idParamMeta = ctx.idParamMeta;
   const methodName = `findAllBy_${sub.childRoute}`;
   def(cls, methodName, async function(id, params) {
-    const { data, count } = await this.repo.findAllByParent(id, sub.childRoute, params);
-    const totalPages = Math.max(1, Math.ceil(count / params.pageSize));
-    return {
-      data,
-      request: {
-        count,
-        page: params.page,
-        pageSize: params.pageSize,
-        totalPages,
-        sort: params.sort,
-        sortDir: params.sortDir,
-        filter: params.filter
-      }
-    };
+    return findAllByParent(this.repo, id, sub.childRoute, params);
   });
   const d = desc(cls, methodName);
   (0, import_common10.Get)(`:id/${sub.childRoute}`)(cls.prototype, methodName, d);
@@ -2336,7 +3029,7 @@ var registerSubResourceCreate = /* @__PURE__ */ __name((ctx, sub) => {
   const { name } = config;
   const methodName = `createChild_${sub.childRoute}`;
   def(cls, methodName, async function(id, body) {
-    return this.repo.createChild(id, sub, body);
+    return createChild(this.repo, id, sub, body);
   });
   const d = desc(cls, methodName);
   (0, import_common10.Post)(`:id/${sub.childRoute}`)(cls.prototype, methodName, d);
@@ -2356,7 +3049,7 @@ var registerSubResourceFindOne = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   const methodName = `findOneChild_${sub.childRoute}`;
   def(cls, methodName, async function(parentId, childId) {
-    return this.repo.findOneChild(sub, childId, parentId);
+    return findOneChild(this.repo, sub, childId, parentId);
   });
   const d = desc(cls, methodName);
   (0, import_common10.Get)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
@@ -2376,7 +3069,7 @@ var registerSubResourceUpdate = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   const methodName = `updateChild_${sub.childRoute}`;
   def(cls, methodName, async function(_id, childId, body) {
-    return this.repo.updateChild(sub, childId, body);
+    return updateChild(this.repo, sub, childId, body);
   });
   const d = desc(cls, methodName);
   (0, import_common10.Patch)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
@@ -2397,7 +3090,7 @@ var registerSubResourceDelete = /* @__PURE__ */ __name((ctx, sub) => {
   const { cls } = ctx;
   const methodName = `deleteChild_${sub.childRoute}`;
   def(cls, methodName, async function(parentId, childId) {
-    return this.repo.deleteChild(sub, childId, parentId);
+    return deleteChild(this.repo, sub, childId, parentId);
   });
   const d = desc(cls, methodName);
   (0, import_common10.Delete)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
@@ -2436,9 +3129,9 @@ function createCrudController(config, baseUrl) {
     throw new Error(`Resource "${name}" declares 'upsert' but no upsertOn`);
   }
   const bodyDecorator = /* @__PURE__ */ __name((schema, options) => {
-    if (!schema) return (0, import_common12.Body)();
-    if (isZodSchema(schema)) return (0, import_common12.Body)(new ZodValidationPipe(schema, options));
-    return (0, import_common12.Body)();
+    if (!schema) return (0, import_common11.Body)();
+    if (isZodSchema(schema)) return (0, import_common11.Body)(new ZodValidationPipe(schema, options));
+    return (0, import_common11.Body)();
   }, "bodyDecorator");
   let CrudControllerBase = class CrudControllerBase {
     static {
@@ -2493,165 +3186,115 @@ function createCrudController(config, baseUrl) {
 }
 __name(createCrudController, "createCrudController");
 
-// src/lib/crud/loader/module.loader.ts
-var import_node_fs2 = require("fs");
-var import_node_module = require("module");
-var import_node_path2 = require("path");
-var import_meta = {};
-var _require = (0, import_node_module.createRequire)(import_meta.url);
-var findModule2 = /* @__PURE__ */ __name((dir, name) => {
-  for (const ext of [
-    ".ts",
-    ".js"
-  ]) {
-    const p = (0, import_node_path2.join)(dir, `${name}${ext}`);
-    if ((0, import_node_fs2.existsSync)(p)) return p;
+// src/lib/crud/builder/column-predicates.ts
+var isBoolean = /* @__PURE__ */ __name((col) => col.fieldInput?.type === "boolean" || col.columnType === "boolean", "isBoolean");
+var isRelation = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "relation", "isRelation");
+var isAutocomplete = /* @__PURE__ */ __name((col) => col.fieldInput?.type === "autocomplete", "isAutocomplete");
+var isRecordCell = /* @__PURE__ */ __name((col) => isRelation(col) || isAutocomplete(col), "isRecordCell");
+var isDateRange = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "date-range", "isDateRange");
+
+// src/lib/crud/builder/column.utils.ts
+var colPosition = /* @__PURE__ */ __name((col, i) => col.fieldInput?.position ?? i, "colPosition");
+var sortByPosition = /* @__PURE__ */ __name((cols) => cols.map((col, i) => ({
+  col,
+  i
+})).sort((a, b) => colPosition(a.col, a.i) - colPosition(b.col, b.i)).map(({ col }) => col), "sortByPosition");
+var toViewColumn = /* @__PURE__ */ __name((col) => ({
+  id: col.id,
+  ...col.label && {
+    label: col.label
+  },
+  ...col.sortable != null && {
+    sortable: col.sortable
+  },
+  ...col.searchable != null && {
+    searchable: col.searchable
+  },
+  ...col.fieldInput && {
+    fieldInput: col.fieldInput
   }
-  return void 0;
-}, "findModule");
-var IS_VITE = typeof globalThis.__vite_ssr_import__ === "function";
-var importDefault = /* @__PURE__ */ __name(async (filePath) => {
-  try {
-    if (IS_VITE) {
-      const importPath = IS_DEV ? `${filePath}?t=${Date.now()}` : filePath;
-      const mod = await import(importPath);
-      return mod.default ?? mod;
-    } else {
-      const mod = _require(filePath);
-      return mod.default;
-    }
-  } catch {
-    return void 0;
+}), "toViewColumn");
+
+// src/lib/crud/builder/sort.helpers.ts
+var deriveSortId = /* @__PURE__ */ __name((col) => {
+  if (col.sortable === false) return null;
+  if (col.sortId) return col.sortId;
+  const base = col.column ?? col.id;
+  const fi = col.fieldInput;
+  const opts = fi?.options ?? {};
+  const isRelation2 = fi?.format === "relation" || !!fi?.relationType || fi?.type === "autocomplete" || typeof opts.resource === "string";
+  if (isRelation2) {
+    const key = (typeof col.displayKey === "string" ? col.displayKey : void 0) ?? (typeof opts.displayKey === "string" ? opts.displayKey : void 0) ?? (typeof opts.labelKey === "string" ? opts.labelKey : void 0);
+    if (!key) return null;
+    const path2 = key.includes(".") ? key : `${base}.${key}`;
+    return path2.endsWith(".label") ? path2.slice(0, -".label".length) : path2;
   }
-}, "importDefault");
+  if (!col.displayKey) return base;
+  const path = `${base}.${col.displayKey}`;
+  const isValueLabel = !!col.enum || opts.emitObject === true;
+  if (isValueLabel && path.endsWith(".label")) return path.slice(0, -".label".length);
+  return path;
+}, "deriveSortId");
+var resolveDefaultSort = /* @__PURE__ */ __name((tableCols, allColumns) => {
+  const isSortable = /* @__PURE__ */ __name((c) => c.sortable !== false, "isSortable");
+  const sortCol = tableCols.find((c) => c.defaultSort && isSortable(c)) ?? tableCols.find(isSortable) ?? allColumns?.find((c) => c.idField);
+  return sortCol ? deriveSortId(sortCol) ?? sortCol.id : void 0;
+}, "resolveDefaultSort");
 
-// src/lib/crud/loader/action.loader.ts
-var import_node_path3 = require("path");
-var loadActions = /* @__PURE__ */ __name(async (jsonActions, basePath) => {
-  const results = [];
-  for (const action of jsonActions) {
-    if (action.type === "link") {
-      results.push({
-        type: "link",
-        id: action.id,
-        label: action.label,
-        href: action.href,
-        ...action.condition && {
-          condition: action.condition
-        }
-      });
-      continue;
-    }
-    const file = findModule2((0, import_node_path3.join)(basePath, "actions"), action.procedure);
-    if (!file) {
-      console.warn(`[actions] Procedure file not found for "${action.id}" in ${basePath}/actions/`);
-      continue;
-    }
-    const mod = await importDefault(file);
-    if (!mod) {
-      console.warn(`[actions] No default export in ${file}`);
-      continue;
+// src/lib/crud/builder/schema-transforms.ts
+var allowAdditionalProperties = /* @__PURE__ */ __name((schema) => {
+  if (schema["type"] === "object") {
+    schema["additionalProperties"] = true;
+    const props = schema["properties"];
+    if (props) {
+      for (const value of Object.values(props)) {
+        allowAdditionalProperties(value);
+      }
     }
-    results.push({
-      id: action.id,
-      label: action.label,
-      method: action.method,
-      data: action.data,
-      ...action.condition && {
-        condition: action.condition
-      },
-      procedure: mod
-    });
   }
-  return results;
-}, "loadActions");
-var loadTableActions = /* @__PURE__ */ __name(async (jsonActions, basePath) => {
-  const results = [];
-  for (const action of jsonActions) {
-    if (action.type === "link") {
-      results.push({
-        type: "link",
-        id: action.id,
-        label: action.label,
-        icon: action.icon,
-        tooltip: action.tooltip,
-        href: action.href
-      });
-      continue;
-    }
-    const file = findModule2((0, import_node_path3.join)(basePath, "actions"), action.procedure);
-    if (!file) {
-      console.warn(`[tableActions] Procedure file not found for "${action.id}" in ${basePath}/actions/`);
-      continue;
-    }
-    const mod = await importDefault(file);
-    if (!mod) {
-      console.warn(`[tableActions] No default export in ${file}`);
-      continue;
-    }
-    results.push({
-      id: action.id,
-      label: action.label,
-      icon: action.icon,
-      tooltip: action.tooltip,
-      method: action.method,
-      data: action.data,
-      procedure: mod
-    });
+  if (schema["type"] === "array" && schema["items"]) {
+    allowAdditionalProperties(schema["items"]);
   }
-  return results;
-}, "loadTableActions");
-
-// src/lib/crud/loader/enum-registry.ts
-var import_node_fs3 = require("fs");
-var import_node_path4 = require("path");
-var ENUMS_FILE = "crouton.enums.json";
-var loadEnumRegistry = /* @__PURE__ */ __name((startDir, enumsFile) => {
-  let file = enumsFile;
-  if (!file) {
-    let dir = startDir;
-    while (true) {
-      const candidate = (0, import_node_path4.join)(dir, ENUMS_FILE);
-      if ((0, import_node_fs3.existsSync)(candidate)) {
-        file = candidate;
-        break;
-      }
-      const parent = (0, import_node_path4.dirname)(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
+}, "allowAdditionalProperties");
+var isNullableProperty2 = /* @__PURE__ */ __name((prop) => {
+  const anyOf = prop?.["anyOf"];
+  return Array.isArray(anyOf) && anyOf.some((s) => s?.["type"] === "null");
+}, "isNullableProperty");
+var dropNullableFromRequired2 = /* @__PURE__ */ __name((schema) => {
+  if (schema["type"] !== "object") return;
+  const props = schema["properties"];
+  if (!props) return;
+  const required = schema["required"];
+  if (Array.isArray(required)) {
+    schema["required"] = required.filter((key) => !isNullableProperty2(props[key]));
   }
-  if (!file || !(0, import_node_fs3.existsSync)(file)) return {};
-  try {
-    return JSON.parse((0, import_node_fs3.readFileSync)(file, "utf-8"));
-  } catch {
-    return {};
+  for (const value of Object.values(props)) {
+    dropNullableFromRequired2(value);
   }
-}, "loadEnumRegistry");
-var injectEnumValues = /* @__PURE__ */ __name((columns, enums) => {
-  if (!columns) return;
-  for (const col of columns) {
-    if (!col.enum) continue;
-    const values = enums[col.enum];
-    if (!values) continue;
-    col.fieldInput = col.fieldInput ?? {
-      type: "select"
-    };
-    const options = col.fieldInput.options ?? {};
-    if (!("values" in options)) options.values = values;
-    col.fieldInput.options = options;
+}, "dropNullableFromRequired");
+var enforceRequiredMinLength = /* @__PURE__ */ __name((schema) => {
+  if (schema["type"] !== "object") return;
+  const props = schema["properties"];
+  if (!props) return;
+  for (const prop of Object.values(props)) {
+    if (prop?.["type"] === "string" && !("minLength" in prop)) {
+      prop["minLength"] = 1;
+    } else if (prop?.["type"] === "object") {
+      enforceRequiredMinLength(prop);
+    }
   }
-}, "injectEnumValues");
-
-// src/lib/crud/loader/json-adapter.ts
-var import_zod9 = require("zod");
+}, "enforceRequiredMinLength");
+var applySchemaTransforms = /* @__PURE__ */ __name((schema) => {
+  allowAdditionalProperties(schema);
+  dropNullableFromRequired2(schema);
+  enforceRequiredMinLength(schema);
+}, "applySchemaTransforms");
 
-// src/lib/crud/loader/schema.helpers.ts
+// src/lib/crud/builder/schema.helpers.ts
 var pickByColumns = /* @__PURE__ */ __name((schema, columns, filter) => {
   if (!schema) return void 0;
   if (!columns?.length) return schema;
-  const isRelation2 = /* @__PURE__ */ __name((c) => c.fieldInput?.format === "relation", "isRelation");
-  const baseFilter = /* @__PURE__ */ __name((c) => !isRelation2(c) && (filter ? filter(c) : true), "baseFilter");
+  const baseFilter = /* @__PURE__ */ __name((c) => !isRelation(c) && (filter ? filter(c) : true), "baseFilter");
   const filtered = columns.filter(baseFilter);
   if (!filtered.length) return void 0;
   const mask = Object.fromEntries(filtered.map((c) => [
@@ -2682,10 +3325,75 @@ var upsertOp = /* @__PURE__ */ __name((entry, schema) => {
   return void 0;
 }, "upsertOp");
 
-// src/lib/crud/loader/view.builders.ts
-var import_zod8 = require("zod");
+// src/lib/crud/builder/table-schema.builder.ts
+var SHARED_CELL_OPTION_KEYS = [
+  "values",
+  "storeValue",
+  "uri",
+  "resourceUri",
+  "schemasUri"
+];
+var pickSharedCellOptions = /* @__PURE__ */ __name((col) => {
+  const options = col.fieldInput?.options ?? {};
+  return Object.fromEntries(SHARED_CELL_OPTION_KEYS.filter((key) => options[key] !== void 0).map((key) => [
+    key,
+    options[key]
+  ]));
+}, "pickSharedCellOptions");
+var buildTableUiSchema = /* @__PURE__ */ __name((cols) => {
+  const layout = TableBuilder.init().addControls(...cols.map((col) => {
+    const cellBuilder = isBoolean(col) ? BooleanCellBuilder : TextCellBuilder;
+    let builder = cellBuilder.properties(col.id);
+    if (col.displayKey) builder = builder.key(col.displayKey);
+    if (col.sortId) builder = builder.setSortId(col.sortId);
+    return builder;
+  })).build();
+  const colMap = Object.fromEntries(cols.map((c) => [
+    c.id,
+    c
+  ]));
+  layout.elements = layout.elements.map((el) => {
+    const id = el.scope?.replace("#/properties/", "");
+    const col = id ? colMap[id] : void 0;
+    if (!col) return el;
+    const fieldInputOptions = isRecordCell(col) || isDateRange(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
+    const dataPathOption = col.column ? {
+      dataPath: col.column
+    } : {};
+    const derivedSortId = isRecordCell(col) || isDateRange(col) ? null : deriveSortId(col);
+    const sortOptions = derivedSortId ? {
+      sortId: derivedSortId
+    } : {
+      sortable: false
+    };
+    const relationTypeOption = col.fieldInput?.relationType ? {
+      relationType: col.fieldInput.relationType
+    } : {};
+    return {
+      ...el,
+      options: {
+        ...el.options ?? {},
+        ...fieldInputOptions,
+        ...dataPathOption,
+        ...sortOptions,
+        ...relationTypeOption,
+        ...isDateRange(col) && {
+          format: "date-range"
+        },
+        label: col.label
+      },
+      ...isRecordCell(col) && {
+        type: "RecordCell"
+      },
+      ...isDateRange(col) && {
+        type: "Control"
+      }
+    };
+  });
+  return layout;
+}, "buildTableUiSchema");
 
-// src/lib/crud/loader/form-schema.builder.ts
+// src/lib/crud/builder/form-schema.builder.ts
 var buildConditionSchema = /* @__PURE__ */ __name((when) => {
   if (when.notExists) return {
     not: {
@@ -2805,232 +3513,7 @@ var buildFormUiSchema = /* @__PURE__ */ __name((cols) => {
   return layout;
 }, "buildFormUiSchema");
 
-// src/lib/crud/loader/schema-transforms.ts
-var allowAdditionalProperties = /* @__PURE__ */ __name((schema) => {
-  if (schema["type"] === "object") {
-    schema["additionalProperties"] = true;
-    const props = schema["properties"];
-    if (props) {
-      for (const value of Object.values(props)) {
-        allowAdditionalProperties(value);
-      }
-    }
-  }
-  if (schema["type"] === "array" && schema["items"]) {
-    allowAdditionalProperties(schema["items"]);
-  }
-}, "allowAdditionalProperties");
-var isNullableProperty2 = /* @__PURE__ */ __name((prop) => {
-  const anyOf = prop?.["anyOf"];
-  return Array.isArray(anyOf) && anyOf.some((s) => s?.["type"] === "null");
-}, "isNullableProperty");
-var dropNullableFromRequired2 = /* @__PURE__ */ __name((schema) => {
-  if (schema["type"] !== "object") return;
-  const props = schema["properties"];
-  if (!props) return;
-  const required = schema["required"];
-  if (Array.isArray(required)) {
-    schema["required"] = required.filter((key) => !isNullableProperty2(props[key]));
-  }
-  for (const value of Object.values(props)) {
-    dropNullableFromRequired2(value);
-  }
-}, "dropNullableFromRequired");
-var enforceRequiredMinLength = /* @__PURE__ */ __name((schema) => {
-  if (schema["type"] !== "object") return;
-  const props = schema["properties"];
-  if (!props) return;
-  for (const prop of Object.values(props)) {
-    if (prop?.["type"] === "string" && !("minLength" in prop)) {
-      prop["minLength"] = 1;
-    } else if (prop?.["type"] === "object") {
-      enforceRequiredMinLength(prop);
-    }
-  }
-}, "enforceRequiredMinLength");
-
-// src/lib/crud/loader/table-schema.builder.ts
-var isBoolean = /* @__PURE__ */ __name((col) => col.fieldInput?.type === "boolean" || col.columnType === "boolean", "isBoolean");
-var isRelation = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "relation", "isRelation");
-var isAutocomplete = /* @__PURE__ */ __name((col) => col.fieldInput?.type === "autocomplete", "isAutocomplete");
-var isRecordCell = /* @__PURE__ */ __name((col) => isRelation(col) || isAutocomplete(col), "isRecordCell");
-var isDateRange = /* @__PURE__ */ __name((col) => col.fieldInput?.format === "date-range", "isDateRange");
-var deriveSortId = /* @__PURE__ */ __name((col) => {
-  if (col.sortable === false) return null;
-  if (col.sortId) return col.sortId;
-  const base = col.column ?? col.id;
-  const fi = col.fieldInput;
-  const opts = fi?.options ?? {};
-  const isRelation2 = fi?.format === "relation" || !!fi?.relationType || fi?.type === "autocomplete" || typeof opts.resource === "string";
-  if (isRelation2) {
-    const key = (typeof col.displayKey === "string" ? col.displayKey : void 0) ?? (typeof opts.displayKey === "string" ? opts.displayKey : void 0) ?? (typeof opts.labelKey === "string" ? opts.labelKey : void 0);
-    if (!key) return null;
-    const path2 = key.includes(".") ? key : `${base}.${key}`;
-    return path2.endsWith(".label") ? path2.slice(0, -".label".length) : path2;
-  }
-  if (!col.displayKey) return base;
-  const path = `${base}.${col.displayKey}`;
-  const isValueLabel = !!col.enum || opts.emitObject === true;
-  if (isValueLabel && path.endsWith(".label")) return path.slice(0, -".label".length);
-  return path;
-}, "deriveSortId");
-var resolveDefaultSort = /* @__PURE__ */ __name((tableCols, allColumns) => {
-  const isSortable = /* @__PURE__ */ __name((c) => c.sortable !== false, "isSortable");
-  const sortCol = tableCols.find((c) => c.defaultSort && isSortable(c)) ?? tableCols.find(isSortable) ?? allColumns?.find((c) => c.idField);
-  return sortCol ? deriveSortId(sortCol) ?? sortCol.id : void 0;
-}, "resolveDefaultSort");
-var SHARED_CELL_OPTION_KEYS = [
-  "values",
-  "storeValue",
-  "uri",
-  "resourceUri",
-  "schemasUri"
-];
-var pickSharedCellOptions = /* @__PURE__ */ __name((col) => {
-  const options = col.fieldInput?.options ?? {};
-  return Object.fromEntries(SHARED_CELL_OPTION_KEYS.filter((key) => options[key] !== void 0).map((key) => [
-    key,
-    options[key]
-  ]));
-}, "pickSharedCellOptions");
-var buildTableUiSchema = /* @__PURE__ */ __name((cols) => {
-  const layout = TableBuilder.init().addControls(...cols.map((col) => {
-    const cellBuilder = isBoolean(col) ? BooleanCellBuilder : TextCellBuilder;
-    let builder = cellBuilder.properties(col.id);
-    if (col.displayKey) builder = builder.key(col.displayKey);
-    if (col.sortId) builder = builder.setSortId(col.sortId);
-    return builder;
-  })).build();
-  const colMap = Object.fromEntries(cols.map((c) => [
-    c.id,
-    c
-  ]));
-  layout.elements = layout.elements.map((el) => {
-    const id = el.scope?.replace("#/properties/", "");
-    const col = id ? colMap[id] : void 0;
-    if (!col) return el;
-    const fieldInputOptions = isRecordCell(col) || isDateRange(col) ? col.fieldInput?.options ?? {} : pickSharedCellOptions(col);
-    const dataPathOption = col.column ? {
-      dataPath: col.column
-    } : {};
-    const derivedSortId = isRecordCell(col) || isDateRange(col) ? null : deriveSortId(col);
-    const sortOptions = derivedSortId ? {
-      sortId: derivedSortId
-    } : {
-      sortable: false
-    };
-    const relationTypeOption = col.fieldInput?.relationType ? {
-      relationType: col.fieldInput.relationType
-    } : {};
-    return {
-      ...el,
-      options: {
-        ...el.options ?? {},
-        ...fieldInputOptions,
-        ...dataPathOption,
-        ...sortOptions,
-        ...relationTypeOption,
-        ...isDateRange(col) && {
-          format: "date-range"
-        },
-        label: col.label
-      },
-      ...isRecordCell(col) && {
-        type: "RecordCell"
-      },
-      ...isDateRange(col) && {
-        type: "Control"
-      }
-    };
-  });
-  return layout;
-}, "buildTableUiSchema");
-
-// src/lib/crud/loader/view.builders.ts
-var patchFilterProperties = /* @__PURE__ */ __name((jsonSchema, columns) => {
-  if (!columns?.length) return;
-  const properties = jsonSchema.properties;
-  if (!properties) return;
-  for (const col of columns) {
-    if (col.fieldInput?.format === "date-range") {
-      delete properties[col.id];
-      const opts = col.fieldInput?.options ?? {};
-      const base = col.label ?? col.id;
-      const fromField = opts["fromField"] ?? "from";
-      const toField = opts["toField"] ?? "to";
-      const dateProp = /* @__PURE__ */ __name((title) => ({
-        type: "string",
-        format: "date",
-        title,
-        "x-field-type": "date"
-      }), "dateProp");
-      properties[`${col.id}->${fromField}`] = dateProp(opts["fromLabel"] ?? `${base} (from)`);
-      properties[`${col.id}->${toField}`] = dateProp(opts["toLabel"] ?? `${base} (to)`);
-      continue;
-    }
-    const prop = properties[col.id];
-    if (!prop) continue;
-    prop.title = col.label ?? col.id;
-    const values = col.fieldInput?.options?.["values"];
-    if (values) {
-      prop["x-values"] = values;
-    }
-    const ft = col.fieldInput?.type;
-    if (ft === "select" || col.enum) {
-      prop["x-field-type"] = "enum";
-    } else if (ft === "number" || prop.type === "number" || prop.type === "integer") {
-      prop["x-field-type"] = "number";
-    } else if (prop.format === "date-time" || prop.format === "date") {
-      prop["x-field-type"] = "date";
-    } else if (prop.type === "boolean") {
-      prop["x-field-type"] = "boolean";
-    }
-  }
-}, "patchFilterProperties");
-var colPosition = /* @__PURE__ */ __name((col, i) => col.fieldInput?.position ?? i, "colPosition");
-var sortByPosition = /* @__PURE__ */ __name((cols) => cols.map((col, i) => ({
-  col,
-  i
-})).sort((a, b) => colPosition(a.col, a.i) - colPosition(b.col, b.i)).map(({ col }) => col), "sortByPosition");
-var toViewColumn = /* @__PURE__ */ __name((col) => ({
-  id: col.id,
-  ...col.label && {
-    label: col.label
-  },
-  ...col.sortable != null && {
-    sortable: col.sortable
-  },
-  ...col.searchable != null && {
-    searchable: col.searchable
-  },
-  ...col.fieldInput && {
-    fieldInput: col.fieldInput
-  }
-}), "toViewColumn");
-var buildView = /* @__PURE__ */ __name((schema, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
-  if (!schema || !columns?.length) return void 0;
-  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
-  if (!visibleCols.length) return void 0;
-  const schemaCols = schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols;
-  const schemaIds = schemaCols.map((c) => c.id);
-  const mask = Object.fromEntries(schemaIds.map((id) => [
-    id,
-    true
-  ]));
-  const picked = schema.pick(mask);
-  const jsonSchema = (0, import_zod8.toJSONSchema)(picked, {
-    target: "draft-07",
-    ...jsonSchemaOpts
-  });
-  allowAdditionalProperties(jsonSchema);
-  dropNullableFromRequired2(jsonSchema);
-  enforceRequiredMinLength(jsonSchema);
-  return {
-    json_schema: jsonSchema,
-    ui_schema: buildUiSchema(visibleCols),
-    columns: visibleCols.map(toViewColumn)
-  };
-}, "buildView");
+// src/lib/crud/builder/calculated-columns.builder.ts
 var isVisibleInMode = /* @__PURE__ */ __name((c, mode) => mode === "table" ? !c.hiddenInTable : !c.hiddenInView, "isVisibleInMode");
 var buildCalculatedElement = /* @__PURE__ */ __name((c, mode) => mode === "table" ? {
   type: c.type === "boolean" ? "BooleanCell" : "TextCell",
@@ -3109,6 +3592,78 @@ var injectCalculatedColumnsIntoView = /* @__PURE__ */ __name((viewConfig, calcul
 }, "injectCalculatedColumnsIntoView");
 var injectCalculatedColumns = /* @__PURE__ */ __name((tableView, calculated) => injectCalculatedColumnsIntoView(tableView, calculated, "table"), "injectCalculatedColumns");
 var injectCalculatedColumnsToView = /* @__PURE__ */ __name((viewConfig, calculated) => injectCalculatedColumnsIntoView(viewConfig, calculated, "view"), "injectCalculatedColumnsToView");
+
+// src/lib/crud/builder/view.builder.ts
+var import_zod20 = require("zod");
+var patchFilterProperties = /* @__PURE__ */ __name((jsonSchema, columns) => {
+  if (!columns?.length) return;
+  const properties = jsonSchema.properties;
+  if (!properties) return;
+  for (const col of columns) {
+    if (col.fieldInput?.format === "date-range") {
+      delete properties[col.id];
+      const opts = col.fieldInput?.options ?? {};
+      const base = col.label ?? col.id;
+      const fromField = opts["fromField"] ?? "from";
+      const toField = opts["toField"] ?? "to";
+      const dateProp = /* @__PURE__ */ __name((title) => ({
+        type: "string",
+        format: "date",
+        title,
+        "x-field-type": "date"
+      }), "dateProp");
+      properties[`${col.id}->${fromField}`] = dateProp(opts["fromLabel"] ?? `${base} (from)`);
+      properties[`${col.id}->${toField}`] = dateProp(opts["toLabel"] ?? `${base} (to)`);
+      continue;
+    }
+    const prop = properties[col.id];
+    if (!prop) continue;
+    prop.title = col.label ?? col.id;
+    const values = col.fieldInput?.options?.["values"];
+    if (values) {
+      prop["x-values"] = values;
+    }
+    const ft = col.fieldInput?.type;
+    if (ft === "select" || col.enum) {
+      prop["x-field-type"] = "enum";
+    } else if (ft === "number" || prop.type === "number" || prop.type === "integer") {
+      prop["x-field-type"] = "number";
+    } else if (prop.format === "date-time" || prop.format === "date") {
+      prop["x-field-type"] = "date";
+    } else if (prop.type === "boolean") {
+      prop["x-field-type"] = "boolean";
+    }
+  }
+}, "patchFilterProperties");
+var buildView = /* @__PURE__ */ __name((schema, columns, visible, buildUiSchema, sort = false, schemaVisible) => {
+  if (!schema || !columns?.length) return void 0;
+  const visibleCols = sort ? sortByPosition(columns.filter(visible)) : columns.filter(visible);
+  if (!visibleCols.length) return void 0;
+  const schemaCols = (schemaVisible ? columns.filter((c) => visible(c) || schemaVisible(c)) : visibleCols).filter((c) => !isRelation(c));
+  const schemaIds = schemaCols.map((c) => c.id);
+  const mask = Object.fromEntries(schemaIds.map((id) => [
+    id,
+    true
+  ]));
+  const picked = schema.pick(mask);
+  const jsonSchema = (0, import_zod20.toJSONSchema)(picked, {
+    target: "draft-07",
+    ...jsonSchemaOpts
+  });
+  applySchemaTransforms(jsonSchema);
+  if (schemaVisible) {
+    const nonEditableIds = new Set(schemaCols.filter((c) => c.idField || c.createable === false && c.updateable === false).map((c) => c.id));
+    const required = jsonSchema["required"];
+    if (Array.isArray(required) && nonEditableIds.size) {
+      jsonSchema["required"] = required.filter((k) => !nonEditableIds.has(k));
+    }
+  }
+  return {
+    json_schema: jsonSchema,
+    ui_schema: buildUiSchema(visibleCols),
+    columns: visibleCols.map(toViewColumn)
+  };
+}, "buildView");
 var emptyTableView = /* @__PURE__ */ __name(() => ({
   json_schema: {
     type: "object",
@@ -3127,7 +3682,7 @@ var buildViews = /* @__PURE__ */ __name((schema, columns) => {
   } else if (columns?.length) {
     views.table = emptyTableView();
   }
-  const form = buildView(schema, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => c.createable === true || c.updateable === true);
+  const form = buildView(schema, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => !c.idField && (c.createable === true || c.updateable === true));
   if (form) views.form = form;
   const filter = buildView(schema, columns, (c) => !!c.filterable, buildFormUiSchema, true);
   if (filter) {
@@ -3147,7 +3702,6 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
         if (!properties[c.column]) {
           properties[c.column] = {
             type: "object",
-            additionalProperties: true,
             properties: {}
           };
         }
@@ -3158,7 +3712,6 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
           if (!target[segment]) {
             target[segment] = {
               type: "object",
-              additionalProperties: true,
               properties: {}
             };
           }
@@ -3169,17 +3722,22 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
           title: c.label ?? c.id
         };
       } else {
+        const opts = c.fieldInput?.options;
+        const isObject = opts?.emitObject === true || c.fieldInput?.type === "autocomplete";
         properties[c.id] = {
-          type: c.columnType ?? "string",
+          ...isObject ? {} : {
+            type: c.columnType ?? "string"
+          },
           title: c.label ?? c.id
         };
       }
     }
-    return {
+    const schema = {
       type: "object",
-      additionalProperties: true,
       properties
     };
+    applySchemaTransforms(schema);
+    return schema;
   }, "buildJsonSchema");
   const fixNestedScopes = /* @__PURE__ */ __name((uiSchema, cols) => {
     const colMap = Object.fromEntries(cols.map((c) => [
@@ -3229,33 +3787,223 @@ var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
   return Object.keys(views).length ? views : void 0;
 }, "buildViewsFromColumns");
 
-// src/lib/crud/loader/json-adapter.ts
+// src/lib/crud/enum-registry/enum-registry.types.ts
+var import_zod21 = require("zod");
+var EnumEntrySchema = import_zod21.z.object({
+  value: import_zod21.z.unknown(),
+  label: import_zod21.z.string()
+});
+var EnumRegistrySchema = import_zod21.z.record(import_zod21.z.string(), import_zod21.z.array(EnumEntrySchema)).default({});
+
+// src/lib/crud/enum-registry/enum-registry.loader.ts
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var ENUMS_FILE = "crouton.enums.json";
+var loadEnumRegistry = /* @__PURE__ */ __name((startDir, enumsFile) => {
+  let file = enumsFile;
+  if (!file) {
+    let dir = startDir;
+    while (true) {
+      const candidate = (0, import_node_path5.join)(dir, ENUMS_FILE);
+      if ((0, import_node_fs3.existsSync)(candidate)) {
+        file = candidate;
+        break;
+      }
+      const parent = (0, import_node_path5.dirname)(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  if (!file || !(0, import_node_fs3.existsSync)(file)) return EnumRegistrySchema.parse(void 0);
+  try {
+    return EnumRegistrySchema.parse(JSON.parse((0, import_node_fs3.readFileSync)(file, "utf-8")));
+  } catch {
+    return EnumRegistrySchema.parse(void 0);
+  }
+}, "loadEnumRegistry");
+
+// src/lib/crud/enum-registry/enum-registry.injector.ts
+var injectEnumValues = /* @__PURE__ */ __name((columns, enums) => {
+  if (!columns) return;
+  for (const col of columns) {
+    if (!col.enum) continue;
+    const values = enums[col.enum];
+    if (!values) continue;
+    col.fieldInput = col.fieldInput ?? {
+      type: "select"
+    };
+    const options = col.fieldInput.options ?? {};
+    if (!("values" in options)) options.values = values;
+    col.fieldInput.options = options;
+  }
+}, "injectEnumValues");
+
+// src/lib/crud/adapter/relation-type.ts
+var import_zod22 = require("zod");
+var unwrapZodType = /* @__PURE__ */ __name((type) => {
+  if (type instanceof import_zod22.ZodOptional || type instanceof import_zod22.ZodNullable) {
+    return unwrapZodType(type.unwrap());
+  }
+  return type;
+}, "unwrapZodType");
+var deriveRelationType = /* @__PURE__ */ __name((schema, columnId) => {
+  if (!schema) return void 0;
+  const field = schema.shape[columnId];
+  if (!field) return void 0;
+  const inner = unwrapZodType(field);
+  return inner instanceof import_zod22.ZodArray ? "oneToMany" : "manyToOne";
+}, "deriveRelationType");
+var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
+  const base = col.column ?? col.id;
+  const fkNames = /* @__PURE__ */ new Set([
+    `${base}_id`,
+    `${col.id}_id`
+  ]);
+  return cols.some((c) => fkNames.has(c.id)) ? "manyToOne" : "oneToMany";
+}, "deriveRelationTypeFromColumns");
+var enrichRelationTypes = /* @__PURE__ */ __name((columns, schema) => {
+  if (!schema) return columns;
+  return columns.map((col) => {
+    const fi = col.fieldInput;
+    if (!fi) return col;
+    const isRelationField = fi.type === "autocomplete" || fi.format === "relation";
+    if (!isRelationField) return col;
+    if (fi.relationType) return col;
+    const derived = deriveRelationType(schema, col.id) ?? deriveRelationTypeFromColumns(col, columns);
+    if (!derived) return col;
+    return {
+      ...col,
+      fieldInput: {
+        ...fi,
+        relationType: derived
+      }
+    };
+  });
+}, "enrichRelationTypes");
+
+// src/lib/crud/resource/ReadResourceJson.ts
 var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
-var resolveChildResource = /* @__PURE__ */ __name((resourcePath, parentDir) => {
-  const directPath = (0, import_node_path5.resolve)(parentDir, resourcePath);
-  if (resourcePath.endsWith(".json") && (0, import_node_fs4.existsSync)(directPath)) {
-    try {
-      return {
-        json: JSON.parse((0, import_node_fs4.readFileSync)(directPath, "utf-8")),
-        dir: (0, import_node_path5.dirname)(directPath)
-      };
-    } catch {
-      return void 0;
-    }
+var import_node_path6 = require("path");
+var readResourceJson = /* @__PURE__ */ __name((jsonPath) => {
+  if (!(0, import_node_fs4.existsSync)(jsonPath)) return void 0;
+  const fileContent = JSON.parse((0, import_node_fs4.readFileSync)(jsonPath, "utf-8"));
+  const resource = ResourceJsonSchema.safeParse(fileContent);
+  if (resource.error) {
+    console.error(resource.error);
+    throw new Error(`Resource cannot be parsed ${jsonPath}`);
   }
-  const childName = resourcePath.replace(/^\.\//, "").replace(/\.resource$/, "");
-  const childJsonPath = (0, import_node_path5.resolve)((0, import_node_path5.dirname)(parentDir), childName, "resource.json");
-  if (!(0, import_node_fs4.existsSync)(childJsonPath)) return void 0;
+  return {
+    json: resource.data,
+    dir: (0, import_node_path6.dirname)(jsonPath)
+  };
+}, "readResourceJson");
+
+// src/lib/crud/adapter/resource-resolver.ts
+var import_node_fs5 = require("fs");
+var import_node_path7 = require("path");
+var resolveChildResource = /* @__PURE__ */ __name((resourcePath, parentDir) => {
+  const directPath = (0, import_node_path7.resolve)(parentDir, resourcePath);
   try {
-    return {
-      json: JSON.parse((0, import_node_fs4.readFileSync)(childJsonPath, "utf-8")),
-      dir: (0, import_node_path5.dirname)(childJsonPath)
-    };
+    if (resourcePath.endsWith(".json") && (0, import_node_fs5.existsSync)(directPath)) {
+      return readResourceJson(directPath);
+    }
+    const childName = resourcePath.replace(/^\.\//, "").replace(/\.resource$/, "");
+    const childJsonPath = (0, import_node_path7.resolve)((0, import_node_path7.dirname)(parentDir), childName, "resource.json");
+    return readResourceJson(childJsonPath);
   } catch {
     return void 0;
   }
 }, "resolveChildResource");
+
+// src/lib/crud/adapter/column-enrichment.ts
+var enrichActionColumns = /* @__PURE__ */ __name((columns, parentRoute, subResources, baseUrl) => {
+  if (!columns) return columns;
+  const base = baseUrl ?? "";
+  return columns.map((col) => {
+    if (col.fieldInput?.format !== "relation") return col;
+    const sub = subResources.find((s) => s.column === col.id);
+    if (!sub) return col;
+    return {
+      ...col,
+      fieldInput: {
+        ...col.fieldInput,
+        options: {
+          ...col.fieldInput.options,
+          uri: `${base}/${parentRoute}/{id}/${sub.childRoute}`,
+          resourceUri: `${base}/${sub.childRoute}`,
+          ...sub.views && {
+            resource: `${base}/${parentRoute}/${sub.childRoute}/schemas`
+          }
+        }
+      }
+    };
+  });
+}, "enrichActionColumns");
+var enrichResourceRefColumns = /* @__PURE__ */ __name((columns, parentDir, baseUrl) => {
+  if (!columns || !parentDir) return columns;
+  const base = baseUrl ?? "";
+  return columns.map((col) => {
+    if (!col.fieldInput?.resource || col.fieldInput.format === "relation") return col;
+    const childResolved = resolveChildResource(col.fieldInput.resource, parentDir);
+    const childRoute = childResolved?.json?.route ?? col.fieldInput.resource.replace(/^\.\//, "").replace(/\.resource$/, "");
+    return {
+      ...col,
+      fieldInput: {
+        ...col.fieldInput,
+        options: {
+          ...col.fieldInput.options,
+          resourceUri: `${base}/${childRoute}`,
+          schemasUri: `${base}/${childRoute}/schemas`
+        }
+      }
+    };
+  });
+}, "enrichResourceRefColumns");
+var enrichNestedRelationColumns = /* @__PURE__ */ __name((cols, dir, baseUrl) => {
+  if (!cols || !dir) return cols;
+  const base = baseUrl ?? "";
+  return cols.map((col) => {
+    if (col.fieldInput?.format !== "relation" || !col.fieldInput.resource) return col;
+    const resolved = resolveChildResource(col.fieldInput.resource, dir);
+    const targetRoute = resolved?.json?.route ?? col.fieldInput.resource.replace(/^\.\//, "").replace(/\/resource\.json$/, "").replace(/\.resource$/, "");
+    const relationType = col.fieldInput.relationType ?? deriveRelationTypeFromColumns(col, cols);
+    return {
+      ...col,
+      fieldInput: {
+        ...col.fieldInput,
+        relationType,
+        options: {
+          ...col.fieldInput.options,
+          uri: `${base}/${targetRoute}`,
+          resourceUri: `${base}/${targetRoute}`,
+          resource: `${base}/${targetRoute}/schemas`
+        }
+      }
+    };
+  });
+}, "enrichNestedRelationColumns");
+var enrichIncludeWithSort = /* @__PURE__ */ __name((include, columns) => {
+  if (!include?.length) return include;
+  return include.map((entry) => {
+    const relationName = typeof entry === "string" ? entry : entry.relation;
+    const col = columns.find((c) => {
+      const opts2 = c.fieldInput?.options;
+      return (c.column ?? c.id) === relationName && opts2?.sort;
+    });
+    if (!col) return entry;
+    const opts = col.fieldInput.options;
+    const orderBy = buildChildSortClause(opts.sort, opts.sortDir ?? "asc");
+    return typeof entry === "string" ? {
+      relation: entry,
+      orderBy
+    } : {
+      ...entry,
+      orderBy
+    };
+  });
+}, "enrichIncludeWithSort");
+
+// src/lib/crud/adapter/column-transforms.ts
 var expandExtendColumns = /* @__PURE__ */ __name((columns, dirPath) => {
   if (!dirPath) return columns;
   const result = [];
@@ -3270,7 +4018,7 @@ var expandExtendColumns = /* @__PURE__ */ __name((columns, dirPath) => {
       result.push(col);
       continue;
     }
-    const refColumns = normalizeColumns(resolved.json.columns) ?? [];
+    const refColumns = resolved.json.columns;
     const parentColumnKey = col.column ?? col.id;
     for (const refCol of refColumns) {
       if (refCol.idField) continue;
@@ -3331,37 +4079,8 @@ var applyRelationFormatDefault = /* @__PURE__ */ __name((cols) => cols?.map((col
   }
   return col;
 }), "applyRelationFormatDefault");
-var deriveRelationTypeFromColumns = /* @__PURE__ */ __name((col, cols) => {
-  const base = col.column ?? col.id;
-  const fkNames = /* @__PURE__ */ new Set([
-    `${base}_id`,
-    `${col.id}_id`
-  ]);
-  return cols.some((c) => fkNames.has(c.id)) ? "manyToOne" : "oneToMany";
-}, "deriveRelationTypeFromColumns");
-var enrichNestedRelationColumns = /* @__PURE__ */ __name((cols, dir, baseUrl) => {
-  if (!cols || !dir) return cols;
-  const base = baseUrl ?? "";
-  return cols.map((col) => {
-    if (col.fieldInput?.format !== "relation" || !col.fieldInput.resource) return col;
-    const resolved = resolveChildResource(col.fieldInput.resource, dir);
-    const targetRoute = resolved?.json?.route ?? col.fieldInput.resource.replace(/^\.\//, "").replace(/\/resource\.json$/, "").replace(/\.resource$/, "");
-    const relationType = col.fieldInput.relationType ?? deriveRelationTypeFromColumns(col, cols);
-    return {
-      ...col,
-      fieldInput: {
-        ...col.fieldInput,
-        relationType,
-        options: {
-          ...col.fieldInput.options,
-          uri: `${base}/${targetRoute}`,
-          resourceUri: `${base}/${targetRoute}`,
-          resource: `${base}/${targetRoute}/schemas`
-        }
-      }
-    };
-  });
-}, "enrichNestedRelationColumns");
+
+// src/lib/crud/adapter/sub-resource.builder.ts
 var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentModel, parentDir, enums = {}, baseUrl) => {
   if (!columns || !parentDir) return [];
   return columns.filter((c) => c.fieldInput?.format === "relation" && c.fieldInput?.resource).map((c) => {
@@ -3369,7 +4088,7 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
     const childJson = childResolved?.json;
     const childDir = childResolved?.dir;
     const childRoute = childJson?.route ?? c.fieldInput.resource.replace(/^\.\//, "").replace(/\.resource$/, "");
-    const rawChildColumns = childJson ? normalizeColumns(childJson.columns) : void 0;
+    const rawChildColumns = childJson?.columns;
     const expandedChildColumns = rawChildColumns ? expandExtendColumns(rawChildColumns, childDir) : void 0;
     const childColumns = applyRelationFormatDefault(expandedChildColumns) ?? expandedChildColumns;
     injectEnumValues(childColumns, enums);
@@ -3431,71 +4150,10 @@ var buildSubResources = /* @__PURE__ */ __name((columns, parentRoute, parentMode
     };
   });
 }, "buildSubResources");
-var enrichActionColumns = /* @__PURE__ */ __name((columns, parentRoute, subResources, baseUrl) => {
-  if (!columns) return columns;
-  const base = baseUrl ?? "";
-  return columns.map((col) => {
-    if (col.fieldInput?.format !== "relation") return col;
-    const sub = subResources.find((s) => s.column === col.id);
-    if (!sub) return col;
-    return {
-      ...col,
-      fieldInput: {
-        ...col.fieldInput,
-        options: {
-          ...col.fieldInput.options,
-          uri: `${base}/${parentRoute}/{id}/${sub.childRoute}`,
-          resourceUri: `${base}/${sub.childRoute}`,
-          ...sub.views && {
-            resource: `${base}/${parentRoute}/${sub.childRoute}/schemas`
-          }
-        }
-      }
-    };
-  });
-}, "enrichActionColumns");
-var enrichResourceRefColumns = /* @__PURE__ */ __name((columns, parentDir, baseUrl) => {
-  if (!columns || !parentDir) return columns;
-  const base = baseUrl ?? "";
-  return columns.map((col) => {
-    if (!col.fieldInput?.resource || col.fieldInput.format === "relation") return col;
-    const childResolved = resolveChildResource(col.fieldInput.resource, parentDir);
-    const childRoute = childResolved?.json?.route ?? col.fieldInput.resource.replace(/^\.\//, "").replace(/\.resource$/, "");
-    return {
-      ...col,
-      fieldInput: {
-        ...col.fieldInput,
-        options: {
-          ...col.fieldInput.options,
-          resourceUri: `${base}/${childRoute}`,
-          schemasUri: `${base}/${childRoute}/schemas`
-        }
-      }
-    };
-  });
-}, "enrichResourceRefColumns");
-var enrichIncludeWithSort = /* @__PURE__ */ __name((include, columns) => {
-  if (!include?.length) return include;
-  return include.map((entry) => {
-    const relationName = typeof entry === "string" ? entry : entry.relation;
-    const col = columns.find((c) => {
-      const opts2 = c.fieldInput?.options;
-      return (c.column ?? c.id) === relationName && opts2?.sort;
-    });
-    if (!col) return entry;
-    const opts = col.fieldInput.options;
-    const orderBy = buildChildSortClause(opts.sort, opts.sortDir ?? "asc");
-    return typeof entry === "string" ? {
-      relation: entry,
-      orderBy
-    } : {
-      ...entry,
-      orderBy
-    };
-  });
-}, "enrichIncludeWithSort");
+
+// src/lib/crud/adapter/json-adapter.ts
 var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, actions, tableActions, enums = {}) => {
-  const rawColumns = expandExtendColumns(normalizeColumns(json.columns) ?? [], dirPath);
+  const rawColumns = expandExtendColumns(json.columns, dirPath);
   const columns = enrichRelationTypes(applyRelationFormatDefault(rawColumns) ?? rawColumns, schema);
   injectEnumValues(columns, enums);
   const subResources = buildSubResources(columns, json.route, json.model, dirPath, enums, baseUrl);
@@ -3539,22 +4197,14 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
       delete: true
     }
   };
-  const display = {
-    mode: json.display?.mode === "page" ? "page" : "modal",
-    customComponent: json.display?.customComponent ?? null
-  };
   return {
+    ...json,
     name: json.name,
     route: json.route,
     model: json.model,
     tag: json.tag,
-    display,
-    ...json.title && {
-      title: json.title
-    },
-    ...json.sidebar && {
-      sidebar: json.sidebar
-    },
+    sidebar: json.sidebar,
+    display: json.display,
     ...json.idType && {
       idType: json.idType
     },
@@ -3597,38 +4247,6 @@ var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, ac
     }
   };
 }, "fromJson");
-var unwrapZodType = /* @__PURE__ */ __name((type) => {
-  if (type instanceof import_zod9.ZodOptional || type instanceof import_zod9.ZodNullable) {
-    return unwrapZodType(type.unwrap());
-  }
-  return type;
-}, "unwrapZodType");
-var deriveRelationType = /* @__PURE__ */ __name((schema, columnId) => {
-  if (!schema) return void 0;
-  const field = schema.shape[columnId];
-  if (!field) return void 0;
-  const inner = unwrapZodType(field);
-  return inner instanceof import_zod9.ZodArray ? "oneToMany" : "manyToOne";
-}, "deriveRelationType");
-var enrichRelationTypes = /* @__PURE__ */ __name((columns, schema) => {
-  if (!schema) return columns;
-  return columns.map((col) => {
-    const fi = col.fieldInput;
-    if (!fi) return col;
-    const isRelationField = fi.type === "autocomplete" || fi.format === "relation";
-    if (!isRelationField) return col;
-    if (fi.relationType) return col;
-    const derived = deriveRelationType(schema, col.id) ?? deriveRelationTypeFromColumns(col, columns);
-    if (!derived) return col;
-    return {
-      ...col,
-      fieldInput: {
-        ...fi,
-        relationType: derived
-      }
-    };
-  });
-}, "enrichRelationTypes");
 var buildLookup = /* @__PURE__ */ __name((columns) => {
   if (!columns) return void 0;
   const keyCol = columns.find((c) => c.idField);
@@ -3642,41 +4260,65 @@ var buildLookup = /* @__PURE__ */ __name((columns) => {
   };
 }, "buildLookup");
 
-// src/lib/crud/loader/index.ts
-var import_node_fs5 = require("fs");
-var import_node_path6 = require("path");
+// src/lib/crud/hooks/hooks.types.ts
+var import_zod23 = require("zod");
+var WriteOpSchema = import_zod23.z.enum([
+  "create",
+  "update",
+  "upsert",
+  "delete"
+]);
+var ReadOpSchema = import_zod23.z.enum([
+  "findAll",
+  "findOne"
+]);
+var ResourceHooksSchema = import_zod23.z.object({
+  beforeWrite: import_zod23.z.custom().optional(),
+  afterWrite: import_zod23.z.custom().optional(),
+  afterRead: import_zod23.z.custom().optional()
+});
+
+// src/lib/crud/hooks/hooks.loader.ts
+var import_node_path8 = require("path");
+var loadResourceHooks = /* @__PURE__ */ __name(async (basePath) => {
+  const file = findModule(basePath, "hooks");
+  return file ? importDefault(file) : void 0;
+}, "loadResourceHooks");
 var loadSubResourceHooks = /* @__PURE__ */ __name(async (subResources, basePath) => {
   for (const sub of subResources) {
-    const file = sub.name ? findModule2((0, import_node_path6.join)(basePath, "hooks"), sub.name) : void 0;
+    const file = sub.name ? findModule((0, import_node_path8.join)(basePath, "hooks"), sub.name) : void 0;
     if (!file) continue;
     const hooks = await importDefault(file);
     if (hooks) sub.hooks = hooks;
   }
 }, "loadSubResourceHooks");
+
+// src/lib/crud/loader/index.ts
+var import_node_fs6 = require("fs");
+var import_node_path9 = require("path");
 var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl, enumsFile) => {
   const enums = loadEnumRegistry(dirPath, enumsFile);
-  const entries = (0, import_node_fs5.readdirSync)(dirPath, {
+  const entries = (0, import_node_fs6.readdirSync)(dirPath, {
     withFileTypes: true
   });
   const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
   const configs = [];
   for (const dir of dirs) {
-    const basePath = (0, import_node_path6.join)(dirPath, dir);
-    const schemaFile = findModule2(basePath, "schema");
+    const basePath = (0, import_node_path9.join)(dirPath, dir);
+    const schemaFile = findModule(basePath, "schema");
     const schema = schemaFile ? await importDefault(schemaFile) : void 0;
-    const hooksFile = findModule2(basePath, "hooks");
-    const hooks = hooksFile ? await importDefault(hooksFile) : void 0;
-    const jsonFile = (0, import_node_path6.join)(basePath, "resource.json");
-    if ((0, import_node_fs5.existsSync)(jsonFile)) {
-      const json = JSON.parse((0, import_node_fs5.readFileSync)(jsonFile, "utf-8"));
-      const actions = await loadActions(json.actions ?? [], basePath);
-      const tableActions = await loadTableActions(json.tableActions ?? [], basePath);
+    const hooks = await loadResourceHooks(basePath);
+    const jsonFile = (0, import_node_path9.join)(basePath, "resource.json");
+    if ((0, import_node_fs6.existsSync)(jsonFile)) {
+      const json = readResourceJson(jsonFile).json;
+      const actions = await loadActions(json.actions ?? [], basePath, "row");
+      const tableActions = await loadActions(json.tableActions ?? [], basePath, "table");
       const config = fromJson(json, schema, hooks, basePath, baseUrl, actions, tableActions, enums);
       await loadSubResourceHooks(config.subResources ?? [], basePath);
       configs.push(config);
       continue;
     }
-    const tsFile = findModule2(basePath, "resource");
+    const tsFile = findModule(basePath, "resource");
     if (tsFile) {
       const config = await importDefault(tsFile);
       if (config) configs.push(hooks ? {
@@ -3727,11 +4369,18 @@ var CroutonApiModule = class _CroutonApiModule {
   static {
     __name(this, "CroutonApiModule");
   }
-  static forResources(configs, dataSources, loader, config) {
+  onModuleInit() {
+    if (!BigInt.prototype.toJSON) {
+      BigInt.prototype.toJSON = function() {
+        return Number(this);
+      };
+    }
+  }
+  static forResources(configs, dataSources, loader, { baseUrl }, config) {
     const dataSourceRegistry = new DataSourceRegistry(dataSources);
     const configRegistry = new ResourceConfigRegistry(loader, configs);
     const controllers = [
-      ...configs.map((c) => createCrudController(c, config.baseUrl)),
+      ...configs.map((c) => createCrudController(c, baseUrl)),
       createAppLayoutController(configs, config.sidebarGroups, config.title, config.autoSave ?? true)
     ];
     return {
@@ -3753,18 +4402,22 @@ var CroutonApiModule = class _CroutonApiModule {
       ]
     };
   }
-  static async forResourceDir(dirPath, dataSourcesPath, config) {
-    const loader = new FileSystemResourceConfigLoader(dirPath, config.baseUrl, config.enumsFile);
-    const configs = await loadResourceConfigsFromDir(dirPath, config.baseUrl, config.enumsFile);
+  static async forResourceDir(dirPath, dataSourcesPath, { baseUrl }) {
+    const config = await loadConfig();
+    const loader = new FileSystemResourceConfigLoader(dirPath, baseUrl, config.enumsFile);
+    const configs = await loadResourceConfigsFromDir(dirPath, baseUrl, config.enumsFile);
     const dataSources = await loadDataSourcesFromDir(dataSourcesPath);
-    return _CroutonApiModule.forResources(configs, dataSources, loader, config);
+    return _CroutonApiModule.forResources(configs, dataSources, loader, {
+      baseUrl
+    }, config);
   }
-  static forLoader(loader, configs, dataSources, config) {
-    return _CroutonApiModule.forResources(configs, dataSources, loader, config);
+  static async forLoader(loader, configs, dataSources, appConfig) {
+    const config = await loadConfig();
+    return _CroutonApiModule.forResources(configs, dataSources, loader, appConfig, config);
   }
 };
 CroutonApiModule = _ts_decorate5([
-  (0, import_common13.Module)({
+  (0, import_common12.Module)({
     controllers: [],
     providers: [],
     exports: []
@@ -3778,6 +4431,8 @@ CroutonApiModule = _ts_decorate5([
   ResourceConfigLoader,
   ResourceConfigRegistry,
   isOperationEnabled,
+  isRowProcedureAction,
+  isTableProcedureAction,
   loadDataSourcesFromDir,
   loadResourceConfigsFromDir,
   resolveDefinition,