@ghentcdh/crouton-api 0.0.1-alpha.1

package/dist/index.cjs

@@ -0,0 +1,3787 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CroutonApiModule: () => CroutonApiModule,
+  DataSourceRegistry: () => DataSourceRegistry,
+  FileSystemResourceConfigLoader: () => FileSystemResourceConfigLoader,
+  ResourceConfigLoader: () => ResourceConfigLoader2,
+  ResourceConfigRegistry: () => ResourceConfigRegistry,
+  isOperationEnabled: () => isOperationEnabled,
+  loadDataSourcesFromDir: () => loadDataSourcesFromDir,
+  loadResourceConfigsFromDir: () => loadResourceConfigsFromDir,
+  resolveDefinition: () => resolveDefinition,
+  schemaFor: () => schemaFor,
+  upsertOnFor: () => upsertOnFor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/crouton-api.module.ts
+var import_common13 = 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");
+
+// ../crouton-core/src/lib/request.model.ts
+var import_zod2 = 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) => {
+  if (Array.isArray(val)) return val;
+  return [
+    val
+  ];
+}), "StringOrArray");
+
+// ../crouton-core/src/lib/request.model.ts
+var SortDirEnum = import_zod2.z.enum([
+  "asc",
+  "desc"
+]);
+var RequestSchema = import_zod2.z.object({
+  page: PositiveRequestNumber().optional().default(1),
+  pageSize: PositiveRequestNumber().optional().default(20),
+  sort: import_zod2.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([])
+});
+var RequestSchemaWithOffset = RequestSchema.transform((schema) => {
+  const { page, pageSize, sort } = schema;
+  return {
+    ...schema,
+    sort: sort || "id",
+    offset: (page - 1) * pageSize
+  };
+});
+
+// ../crouton-core/src/lib/filter.ts
+var Operator = [
+  "contains",
+  "not_contains",
+  "equals",
+  "not_equals",
+  "gt",
+  "lt",
+  "isnull",
+  "isnotnull"
+];
+var OperatorLabel = {
+  contains: "contains",
+  not_contains: "not contains",
+  equals: "equals",
+  not_equals: "not equals",
+  gt: ">",
+  lt: "<",
+  isnull: "is empty",
+  isnotnull: "is not empty"
+};
+var OperatorOptions = Operator.map((k) => ({
+  value: k,
+  label: OperatorLabel[k]
+}));
+var buildSort = /* @__PURE__ */ __name((key, sortDir) => buildSortKey(key.split("."), SortDirEnum.safeParse(sortDir).data ?? "asc"), "buildSort");
+var buildSortKey = /* @__PURE__ */ __name((keys, sortDir) => {
+  if (keys.length === 1) return {
+    [keys[0]]: sortDir
+  };
+  const buildKey = keys.pop();
+  return buildSortKey(keys, {
+    [buildKey]: sortDir
+  });
+}, "buildSortKey");
+
+// ../crouton-core/src/lib/response.model.ts
+var import_zod4 = 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()),
+  request: ResponseRequestSchema
+});
+
+// ../crouton-core/src/lib/create-schema.ts
+var import_zod6 = require("zod");
+
+// ../crouton-core/src/lib/layout/base.builder.ts
+var Builder = class {
+  static {
+    __name(this, "Builder");
+  }
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var BuilderWithElements = class extends Builder {
+  static {
+    __name(this, "BuilderWithElements");
+  }
+  elements = [];
+  addControl(control) {
+    this.elements.push(control);
+    return this;
+  }
+  addControls(...controls) {
+    this.elements.push(...controls);
+    return this;
+  }
+  buildElements() {
+    return this.elements.map((e) => e.build());
+  }
+};
+
+// ../crouton-core/src/lib/layout/control.builder.ts
+var ControlType = {
+  number: "number",
+  string: "string",
+  integer: "Integer",
+  autocomplete: "autocomplete",
+  textArea: "textarea",
+  markdown: "markdown",
+  array: "array",
+  custom: "custom",
+  select: "select",
+  mutliSelect: "mutliSelect",
+  boolean: "boolean",
+  link: "link",
+  relation: "relation",
+  date: "date",
+  dateTime: "dateTime",
+  dateRange: "date-range"
+};
+var ControlBuilder = class _ControlBuilder extends Builder {
+  static {
+    __name(this, "ControlBuilder");
+  }
+  scope;
+  options = {
+    format: "Control",
+    styles: {}
+  };
+  _detail;
+  constructor(scope, type = "Control") {
+    super(type), this.scope = scope;
+  }
+  static asObject(property) {
+    return new _ControlBuilder(`#/properties/${property}`, "Object");
+  }
+  static properties(property) {
+    return new _ControlBuilder(`#/properties/${property}`);
+  }
+  static asCustom(property, type) {
+    const builder = new _ControlBuilder(`#/properties/${property}`);
+    builder.addOptions({
+      format: ControlType.custom,
+      type
+    });
+    return builder;
+  }
+  setCustomRender(customRender) {
+    this.addOptions({
+      customRender
+    });
+    return this;
+  }
+  detail(layoutBuilder, label) {
+    this._detail = layoutBuilder;
+    this.addOptions({
+      format: ControlType.array,
+      elementLabelProp: label
+    });
+    return this;
+  }
+  addAction(action) {
+    const actions = this.options?.actions ?? [];
+    actions.push(action);
+    return this.addOptions({
+      actions
+    });
+  }
+  detailFixed(layoutBuilder, options = {}) {
+    this._detail = layoutBuilder;
+    return this.addOptions({
+      hideActions: true,
+      format: ControlType.array,
+      layout: options.layout ?? "column",
+      elementLabelProp: options.label
+    });
+  }
+  labelKey(labelKey) {
+    return this.addOptions({
+      labelKey
+    });
+  }
+  readonly() {
+    return this.addOptions({
+      format: ControlType.string,
+      readonly: true
+    });
+  }
+  link() {
+    return this.addOptions({
+      format: ControlType.link
+    });
+  }
+  markdown(options) {
+    return this.addOptions({
+      format: ControlType.markdown,
+      ...options ?? {}
+    });
+  }
+  textArea(options) {
+    return this.addOptions({
+      format: ControlType.textArea,
+      ...options ?? {}
+    });
+  }
+  autocomplete(options) {
+    return this.addOptions({
+      format: ControlType.autocomplete,
+      dataField: "data",
+      ...options ?? {}
+    });
+  }
+  control(format, options) {
+    return this.addOptions({
+      format,
+      ...options
+    });
+  }
+  select(options) {
+    return this.addOptions({
+      format: ControlType.select,
+      ...options
+    });
+  }
+  mutliSelect(options) {
+    return this.addOptions({
+      format: ControlType.mutliSelect,
+      ...options
+    });
+  }
+  width(width) {
+    return this.addOptions({
+      styles: {
+        ...this.options?.styles,
+        width,
+        control: {
+          wrapper: `input-${width}`
+        }
+      }
+    });
+  }
+  customLabel(label) {
+    return this.addOptions({
+      label
+    });
+  }
+  placeHolder(placeholder) {
+    return this.addOptions({
+      placeholder
+    });
+  }
+  hideLabel() {
+    return this.addOptions({
+      hideLabel: true
+    });
+  }
+  addOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    return this;
+  }
+  build() {
+    return {
+      type: this.type,
+      scope: this.scope,
+      options: {
+        ...this.options,
+        detail: this._detail ? this._detail?.build() : void 0
+      }
+    };
+  }
+};
+
+// ../crouton-core/src/lib/layout/layout.builder.ts
+var LayoutTypes = {
+  HorizontalLayout: "HorizontalLayout",
+  VerticalLayout: "VerticalLayout",
+  CollapseLayout: "CollapseLayout",
+  GridLayout: "GridLayout"
+};
+var LayoutBuilder = class _LayoutBuilder extends BuilderWithElements {
+  static {
+    __name(this, "LayoutBuilder");
+  }
+  options;
+  constructor(type, options = {}) {
+    super(type);
+    this.options = options;
+  }
+  static horizontal() {
+    return new _LayoutBuilder(LayoutTypes.HorizontalLayout);
+  }
+  static collapse() {
+    return new _LayoutBuilder(LayoutTypes.CollapseLayout);
+  }
+  static vertical() {
+    return new _LayoutBuilder(LayoutTypes.VerticalLayout);
+  }
+  static grid() {
+    return new _LayoutBuilder(LayoutTypes.GridLayout);
+  }
+  titleKey(titleKey) {
+    return this.addOptions({
+      titleKey
+    });
+  }
+  title(title) {
+    return this.addOptions({
+      title
+    });
+  }
+  addOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    return this;
+  }
+  build() {
+    return {
+      type: this.type,
+      elements: this.buildElements(),
+      options: this.options
+    };
+  }
+};
+
+// ../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);
+  return {
+    value,
+    label: match ? match.label : String(value)
+  };
+}, "wrapOne");
+var toValueLabel = /* @__PURE__ */ __name((value, values) => {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) return value.map((v) => wrapOne(v, values));
+  return wrapOne(value, values);
+}, "toValueLabel");
+var fromValueLabel = /* @__PURE__ */ __name((input) => {
+  if (Array.isArray(input)) return input.map(fromValueLabel);
+  if (input && typeof input === "object" && "value" in input) {
+    return input.value;
+  }
+  return input;
+}, "fromValueLabel");
+
+// ../crouton-core/src/lib/table/table.builder.ts
+var TextCellBuilder = class _TextCellBuilder extends Builder {
+  static {
+    __name(this, "TextCellBuilder");
+  }
+  scope;
+  options;
+  constructor(scope, type = "TextCell") {
+    super(type), this.scope = scope;
+  }
+  static properties(property) {
+    return new _TextCellBuilder(`#/properties/${property}`);
+  }
+  key(key) {
+    this.options = {
+      format: "keyValue",
+      key
+    };
+    return this;
+  }
+  setSortId(sortId) {
+    this.options = {
+      ...this.options ?? {
+        format: this.type
+      },
+      sortId
+    };
+    return this;
+  }
+  build() {
+    return {
+      type: this.type,
+      scope: this.scope,
+      options: this.options
+    };
+  }
+};
+var BooleanCellBuilder = class _BooleanCellBuilder extends TextCellBuilder {
+  static {
+    __name(this, "BooleanCellBuilder");
+  }
+  constructor(scope) {
+    super(scope, "BooleanCell");
+  }
+  static properties(property) {
+    return new _BooleanCellBuilder(`#/properties/${property}`);
+  }
+};
+var TableBuilder = class _TableBuilder {
+  static {
+    __name(this, "TableBuilder");
+  }
+  builder;
+  constructor() {
+    this.builder = LayoutBuilder.horizontal();
+  }
+  static init() {
+    return new _TableBuilder();
+  }
+  addControl(control) {
+    this.builder.addControls(control);
+    return this;
+  }
+  addControls(...controls) {
+    this.builder.addControls(...controls);
+    return this;
+  }
+  build() {
+    return this.builder.build();
+  }
+};
+
+// src/lib/crud/dev-mode.ts
+var IS_DEV = process.env["NODE_ENV"] !== "production";
+
+// src/lib/crud/resource-config.registry.ts
+var import_common = require("@nestjs/common");
+function _ts_decorate(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var ResourceConfigRegistry = class {
+  static {
+    __name(this, "ResourceConfigRegistry");
+  }
+  loader;
+  configs;
+  constructor(loader, initialConfigs) {
+    this.loader = loader;
+    this.configs = initialConfigs;
+  }
+  async getAll() {
+    if (IS_DEV) {
+      this.configs = await this.loader.loadAll();
+    }
+    return this.configs;
+  }
+  async getByRoute(route) {
+    if (IS_DEV) {
+      return this.loader.loadByRoute(route);
+    }
+    return this.configs.find((c) => c.route === route);
+  }
+};
+ResourceConfigRegistry = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ResourceConfigLoader === "undefined" ? Object : ResourceConfigLoader,
+    Array
+  ])
+], ResourceConfigRegistry);
+
+// src/lib/crud/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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+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 {
+    static {
+      __name(this, "AppLayoutController");
+    }
+    configRegistry;
+    constructor(configRegistry) {
+      this.configRegistry = configRegistry;
+    }
+    async getLayout() {
+      if (IS_DEV) {
+        const fresh = await this.configRegistry.getAll();
+        return buildLayoutPayload(fresh, sidebarGroups, title, autoSave);
+      }
+      return layoutPayload;
+    }
+  };
+  _ts_decorate2([
+    (0, import_common2.Get)("layout"),
+    (0, import_swagger.ApiOperation)({
+      summary: "Get the application layout (sidebar, \u2026)"
+    }),
+    (0, import_swagger.ApiResponse)({
+      status: 200,
+      description: "Application layout metadata"
+    }),
+    _ts_metadata2("design:type", Function),
+    _ts_metadata2("design:paramtypes", []),
+    _ts_metadata2("design:returntype", Promise)
+  ], AppLayoutController.prototype, "getLayout", null);
+  AppLayoutController = _ts_decorate2([
+    (0, import_common2.Controller)("_app"),
+    (0, import_swagger.ApiTags)("App"),
+    _ts_metadata2("design:type", Function),
+    _ts_metadata2("design:paramtypes", [
+      typeof ResourceConfigRegistry === "undefined" ? Object : ResourceConfigRegistry
+    ])
+  ], AppLayoutController);
+  Reflect.defineMetadata("design:paramtypes", [
+    ResourceConfigRegistry
+  ], AppLayoutController);
+  return AppLayoutController;
+}, "createAppLayoutController");
+
+// src/lib/crud/crouton-validation.filter.ts
+var import_common3 = require("@nestjs/common");
+
+// src/lib/crud/crouton-validation.error.ts
+var CroutonValidationError = class extends Error {
+  static {
+    __name(this, "CroutonValidationError");
+  }
+  errors;
+  constructor(errors) {
+    super("Validation failed"), this.errors = errors;
+    this.name = "CroutonValidationError";
+  }
+};
+
+// src/lib/crud/crouton-validation.filter.ts
+function _ts_decorate3(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+var CroutonValidationExceptionFilter = class {
+  static {
+    __name(this, "CroutonValidationExceptionFilter");
+  }
+  catch(exception, host) {
+    const res = host.switchToHttp().getResponse();
+    res.status(400).json({
+      statusCode: 400,
+      message: exception.errors,
+      error: "Bad Request"
+    });
+  }
+};
+CroutonValidationExceptionFilter = _ts_decorate3([
+  (0, import_common3.Catch)(CroutonValidationError)
+], CroutonValidationExceptionFilter);
+
+// 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/sql.helpers.ts
+var castExpression = /* @__PURE__ */ __name((col) => {
+  if (col.type === "string") return `(${col.sqlExpression})`;
+  if (col.type === "boolean") return `CAST((${col.sqlExpression}) AS BOOLEAN)`;
+  return `CAST((${col.sqlExpression}) AS INTEGER)`;
+}, "castExpression");
+var defaultValueForType = /* @__PURE__ */ __name((col) => {
+  if (col.type === "boolean") return false;
+  if (col.type === "string") return null;
+  return 0;
+}, "defaultValueForType");
+var coerceColumnValue = /* @__PURE__ */ __name((col) => {
+  if (col.type === "boolean") return (v) => Boolean(v);
+  if (col.type === "string") return (v) => v === void 0 || v === null ? null : String(v);
+  return (v) => Number(v ?? 0);
+}, "coerceColumnValue");
+var buildCalculatedColumnSql = /* @__PURE__ */ __name((col, tableName, ids) => {
+  const alias = col.alias ?? col.id;
+  const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ");
+  return `SELECT main.id, ${castExpression(col)} AS "${alias}" FROM "${tableName}" main WHERE main.id IN (${placeholders})`;
+}, "buildCalculatedColumnSql");
+var mergeCalculatedColumnsForRows = /* @__PURE__ */ __name(async (rows, calcCols, tableName, prisma) => {
+  if (!calcCols.length || !rows.length) return rows;
+  const ids = rows.map((r) => r.id);
+  const results = await Promise.all(calcCols.map(async (col) => {
+    const alias = col.alias ?? col.id;
+    const sql = buildCalculatedColumnSql(col, tableName, ids);
+    const defaultValue = defaultValueForType(col);
+    const coerce = coerceColumnValue(col);
+    try {
+      const calcRows = await prisma.$queryRawUnsafe(sql, ...ids);
+      return {
+        id: col.id,
+        defaultValue,
+        map: Object.fromEntries(calcRows.map((r) => [
+          String(r.id),
+          coerce(r[alias])
+        ]))
+      };
+    } catch (e) {
+      console.error(`[calculatedColumns] Failed for "${tableName}.${col.id}":`, e);
+      return {
+        id: col.id,
+        defaultValue,
+        map: {}
+      };
+    }
+  }));
+  return rows.map((row) => {
+    const extra = {};
+    for (const { id, defaultValue, map } of results) {
+      extra[id] = map[String(row.id)] ?? defaultValue;
+    }
+    return {
+      ...row,
+      ...extra
+    };
+  });
+}, "mergeCalculatedColumnsForRows");
+var buildIncludeClause = /* @__PURE__ */ __name((include) => {
+  if (!include?.length) return void 0;
+  const map = /* @__PURE__ */ new Map();
+  const orderByMap = /* @__PURE__ */ new Map();
+  for (const entry of include) {
+    if (typeof entry === "string") {
+      const dotIdx = entry.indexOf(".");
+      if (dotIdx === -1) {
+        if (!map.has(entry)) map.set(entry, []);
+      } else {
+        const relation = entry.slice(0, dotIdx);
+        const rest = entry.slice(dotIdx + 1);
+        map.set(relation, [
+          ...map.get(relation) ?? [],
+          rest
+        ]);
+      }
+    } else {
+      map.set(entry.relation, [
+        ...map.get(entry.relation) ?? [],
+        ...entry.include ?? []
+      ]);
+      if (entry.orderBy) orderByMap.set(entry.relation, entry.orderBy);
+    }
+  }
+  return Object.fromEntries(Array.from(map.entries()).map(([relation, nestedIncludes]) => {
+    const orderBy = orderByMap.get(relation);
+    if (!nestedIncludes.length && !orderBy) return [
+      relation,
+      true
+    ];
+    const nested = buildIncludeClause(nestedIncludes);
+    const clause = {};
+    if (nested) clause.include = nested;
+    if (orderBy) clause.orderBy = orderBy;
+    return [
+      relation,
+      clause
+    ];
+  }));
+}, "buildIncludeClause");
+var buildChildSortClause = /* @__PURE__ */ __name((sort, sortDir) => {
+  const parts = sort.split(".");
+  if (parts.length === 1) return buildSort(sort, sortDir);
+  const dir = sortDir ?? "asc";
+  return parts.reduceRight((acc, part, i) => i === parts.length - 1 ? {
+    [part]: dir
+  } : {
+    [part]: acc
+  }, {});
+}, "buildChildSortClause");
+
+// src/lib/crud/read.repository.ts
+var parseFilterString = /* @__PURE__ */ __name((raw) => {
+  const parts = raw.split(":");
+  if (parts.length < 2 || !parts[0]) return null;
+  const field = parts[0];
+  const lastPart = parts[parts.length - 1];
+  const hasOperator = Operator.includes(lastPart);
+  const value = hasOperator ? parts.slice(1, -1).join(":") : parts.slice(1).join(":");
+  const operator = hasOperator ? lastPart : "contains";
+  return {
+    field,
+    value,
+    operator
+  };
+}, "parseFilterString");
+var buildNestedPath = /* @__PURE__ */ __name((path, condition) => {
+  if (path.length === 1) return {
+    [path[0]]: condition
+  };
+  const [head, ...rest] = path;
+  return {
+    [head]: buildNestedPath(rest, condition)
+  };
+}, "buildNestedPath");
+var JSON_PATH_SEP = "->";
+var isJsonPath = /* @__PURE__ */ __name((field) => field.includes(JSON_PATH_SEP), "isJsonPath");
+var buildJsonPathCondition = /* @__PURE__ */ __name((field, value, operator) => {
+  const [column, ...path] = field.split(JSON_PATH_SEP);
+  if (!column || path.length === 0) return null;
+  const frag = /* @__PURE__ */ __name((extra) => ({
+    [column]: {
+      path,
+      ...extra
+    }
+  }), "frag");
+  switch (operator) {
+    case "equals":
+      return frag({
+        equals: value
+      });
+    case "not_equals":
+      return frag({
+        not: value
+      });
+    case "gt":
+      return frag({
+        gt: value
+      });
+    case "lt":
+      return frag({
+        lt: value
+      });
+    case "contains":
+      return frag({
+        string_contains: value
+      });
+    case "not_contains":
+      return {
+        NOT: frag({
+          string_contains: value
+        })
+      };
+    // isnull/isnotnull on a json sub-path are not supported — filter on the
+    // whole column instead if you need an emptiness check.
+    default:
+      return null;
+  }
+}, "buildJsonPathCondition");
+var operatorToCondition = /* @__PURE__ */ __name((value, operator) => {
+  const num = Number(value);
+  const numVal = Number.isNaN(num) ? value : num;
+  switch (operator) {
+    case "contains":
+      return {
+        contains: value
+      };
+    case "not_contains":
+      return {
+        not: {
+          contains: value
+        }
+      };
+    case "equals":
+      return {
+        equals: value
+      };
+    case "not_equals":
+      return {
+        not: value
+      };
+    case "gt":
+      return {
+        gt: numVal
+      };
+    case "lt":
+      return {
+        lt: numVal
+      };
+    case "isnull":
+      return null;
+    case "isnotnull":
+      return {
+        not: null
+      };
+    default:
+      return void 0;
+  }
+}, "operatorToCondition");
+var buildFilterWhere = /* @__PURE__ */ __name((filter) => {
+  if (!filter?.length) return void 0;
+  const conditions = filter.map(parseFilterString).filter((f) => f !== null).map(({ field, value, operator }) => isJsonPath(field) ? buildJsonPathCondition(field, value, operator) : buildNestedPath(field.split("."), operatorToCondition(value, operator))).filter((c) => c !== null);
+  return conditions.length ? {
+    AND: conditions
+  } : void 0;
+}, "buildFilterWhere");
+var sanitizeValueLabelSort = /* @__PURE__ */ __name((sort, cols) => {
+  if (!sort || !cols?.length || !sort.endsWith(".label")) return sort;
+  const base = sort.slice(0, -".label".length);
+  const leaf = base.split(".").pop();
+  return cols.some((c) => c.field === base || c.field === leaf) ? base : sort;
+}, "sanitizeValueLabelSort");
+var orderableChildSort = /* @__PURE__ */ __name((sort, childModel, _sub) => {
+  if (!sort) return void 0;
+  const scalarFields = new Set(Object.keys(childModel?.fields ?? {}));
+  if (scalarFields.size === 0) return sort;
+  if (sort.includes(".")) return sort;
+  return scalarFields.has(sort) ? sort : void 0;
+}, "orderableChildSort");
+var applyValueLabelColumns = /* @__PURE__ */ __name((row, cols) => {
+  if (!row || !cols?.length) return row;
+  const out = {
+    ...row
+  };
+  for (const { field, values } of cols) {
+    if (field in out) out[field] = toValueLabel(out[field], values);
+  }
+  return out;
+}, "applyValueLabelColumns");
+var ReadRepository = class {
+  static {
+    __name(this, "ReadRepository");
+  }
+  prismaModel;
+  prisma;
+  config;
+  listSelect;
+  oneSelect;
+  constructor(prismaModel, prisma, config, listSelect, oneSelect) {
+    this.prismaModel = prismaModel;
+    this.prisma = prisma;
+    this.config = config;
+    this.listSelect = listSelect;
+    this.oneSelect = oneSelect;
+  }
+  toId(id) {
+    return (this.config.idType ?? "string") === "number" ? +id : String(id);
+  }
+  buildWhere(filter) {
+    return buildFilterWhere(filter);
+  }
+  projection(op) {
+    const select = op === "findAll" ? this.listSelect : this.oneSelect;
+    return select ? {
+      select
+    } : {};
+  }
+  safeSort(sort, sortDir) {
+    if (!sort) return void 0;
+    if (this.listSelect && !(sort in this.listSelect)) return void 0;
+    return buildSort(sort, sortDir);
+  }
+  async decorate(rows, op) {
+    const hook = this.config.hooks?.afterRead;
+    const hooked = hook ? await Promise.all(rows.map((row) => hook(row, {
+      prisma: this.prisma,
+      op
+    }))) : rows;
+    const cols = this.config.valueLabelColumns;
+    return cols?.length ? hooked.map((r) => applyValueLabelColumns(r, cols)) : hooked;
+  }
+  async decorateOne(row, op) {
+    const hook = this.config.hooks?.afterRead;
+    return hook ? hook(row, {
+      prisma: this.prisma,
+      op
+    }) : row;
+  }
+  /**
+  * Fetch a paginated, sorted, and filtered list of records.
+  * Sub-resource counts are merged onto each row; calculated columns are resolved via raw SQL.
+  */
+  async findAll(params) {
+    const subResources = this.config.subResources ?? [];
+    const projection = this.projection("findAll");
+    let query = {
+      where: this.buildWhere(params.filter),
+      take: params.pageSize,
+      skip: params.offset ?? (params.page - 1) * params.pageSize,
+      orderBy: this.safeSort(sanitizeValueLabelSort(params.sort, this.config.valueLabelColumns), params.sortDir)
+    };
+    if (subResources.length) {
+      const countClause = {
+        select: Object.fromEntries(subResources.map((s) => [
+          s.relation,
+          true
+        ]))
+      };
+      if (projection.select) {
+        query.select = {
+          ...projection.select,
+          _count: countClause
+        };
+      } else {
+        query = {
+          ...query,
+          _count: countClause
+        };
+      }
+    } else {
+      Object.assign(query, projection);
+    }
+    const rows = await this.prismaModel.findMany(query);
+    const mapped = subResources.length ? rows.map((row) => {
+      const { _count, ...rest } = row;
+      if (!_count) return rest;
+      const counts = Object.fromEntries(subResources.map((s) => [
+        s.column,
+        _count[s.relation] ?? 0
+      ]));
+      return {
+        ...rest,
+        ...counts
+      };
+    }) : rows;
+    const withCalc = await mergeCalculatedColumnsForRows(mapped, this.config.calculatedColumns ?? [], this.config.model, this.prisma);
+    return this.decorate(withCalc, "findAll");
+  }
+  /** Count records matching the given filter strings. */
+  count(filter) {
+    return this.prismaModel.count({
+      where: this.buildWhere(filter)
+    });
+  }
+  /**
+  * Fetch a single record by id.
+  * Sub-resources with `includeInFindOne: true` are eagerly loaded (flat).
+  * `config.include` entries are loaded with full nesting via `buildIncludeClause`.
+  * @throws {NotFoundException} When no record exists for the given id.
+  */
+  async findOne(id) {
+    const formIncludes = (this.config.subResources ?? []).filter((s) => s.includeInFindOne).map((s) => s.relation);
+    const projection = this.projection("findOne");
+    const idField = this.config.idField ?? "id";
+    const query = {
+      where: {
+        [idField]: this.toId(id)
+      },
+      ...projection
+    };
+    const flatIncludes = formIncludes.length ? Object.fromEntries(formIncludes.map((r) => [
+      r,
+      true
+    ])) : void 0;
+    const configInclude = buildIncludeClause(this.config.include);
+    const mergedInclude = flatIncludes || configInclude ? {
+      ...flatIncludes,
+      ...configInclude
+    } : void 0;
+    if (mergedInclude) {
+      if (projection.select) {
+        query.select = {
+          ...projection.select,
+          ...mergedInclude
+        };
+      } else {
+        query.include = mergedInclude;
+      }
+    }
+    const record = await this.prismaModel.findUnique(query);
+    if (!record) throw new import_common4.NotFoundException(`${this.config.name} with id ${id} not found`);
+    const [withCalc] = await mergeCalculatedColumnsForRows([
+      record
+    ], this.config.calculatedColumns ?? [], this.config.model, this.prisma);
+    let enriched = withCalc ?? record;
+    for (const sub of this.config.subResources ?? []) {
+      if (!sub.calculatedColumns?.length) continue;
+      const nested = enriched[sub.relation];
+      if (!Array.isArray(nested) || !nested.length) continue;
+      const enrichedNested = await mergeCalculatedColumnsForRows(nested, sub.calculatedColumns, sub.childModel, this.prisma);
+      enriched = {
+        ...enriched,
+        [sub.relation]: enrichedNested
+      };
+    }
+    return this.decorateOne(enriched, "findOne");
+  }
+  /**
+  * Fetch a paginated list of child records belonging to the given parent.
+  * @param childRoute - Matches the `childRoute` key on a `SubResourceConfig`.
+  * @throws {Error} When no matching sub-resource config or Prisma model is found.
+  */
+  async findAllByParent(parentId, childRoute, params) {
+    const sub = (this.config.subResources ?? []).find((s) => s.childRoute === childRoute);
+    if (!sub) throw new Error(`No sub-resource "${childRoute}" on "${this.config.name}"`);
+    const childModel = this.prisma[sub.childModel];
+    if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
+    const where = {
+      ...this.buildWhere(params.filter),
+      [sub.foreignKey]: this.toId(parentId)
+    };
+    const includeClause = buildIncludeClause(sub.include);
+    const childSort = orderableChildSort(sanitizeValueLabelSort(params.sort, sub.valueLabelColumns), childModel, sub);
+    const [data, count] = await Promise.all([
+      childModel.findMany({
+        where,
+        take: params.pageSize,
+        skip: params.offset ?? (params.page - 1) * params.pageSize,
+        orderBy: childSort ? buildChildSortClause(childSort, params.sortDir) : void 0,
+        ...includeClause && {
+          include: includeClause
+        }
+      }),
+      childModel.count({
+        where
+      })
+    ]);
+    const withCalc = sub.calculatedColumns?.length ? await mergeCalculatedColumnsForRows(data, sub.calculatedColumns, sub.childModel, this.prisma) : data;
+    const decorated = sub.hooks?.afterRead ? await Promise.all(withCalc.map((row) => sub.hooks.afterRead(row, {
+      prisma: this.prisma,
+      op: "findAll"
+    }))) : withCalc;
+    const labeled = sub.valueLabelColumns?.length ? decorated.map((r) => applyValueLabelColumns(r, sub.valueLabelColumns)) : decorated;
+    return {
+      data: labeled,
+      count
+    };
+  }
+  /**
+  * Fetch a single child record. When `parentId` is supplied the query also filters by the foreign key.
+  * @throws {NotFoundException} When no matching record is found.
+  */
+  async findOneChild(sub, childId, parentId) {
+    const childModel = this.prisma[sub.childModel];
+    if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
+    const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
+    const idField = sub.idField ?? "id";
+    const where = {
+      [idField]: id
+    };
+    if (parentId !== void 0) where[sub.foreignKey] = this.toId(parentId);
+    const includeClause = buildIncludeClause(sub.include);
+    const record = await childModel.findFirst({
+      where,
+      ...includeClause && {
+        include: includeClause
+      }
+    });
+    if (!record) throw new import_common4.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+    const [withCalc] = sub.calculatedColumns?.length ? await mergeCalculatedColumnsForRows([
+      record
+    ], sub.calculatedColumns, sub.childModel, this.prisma) : [
+      record
+    ];
+    if (sub.hooks?.afterRead) return sub.hooks.afterRead(withCalc, {
+      prisma: this.prisma,
+      op: "findOne"
+    });
+    return withCalc;
+  }
+};
+
+// src/lib/crud/schema.utils.ts
+var import_zod7 = require("zod");
+var dateOverride = /* @__PURE__ */ __name(({ zodSchema, jsonSchema }) => {
+  if (zodSchema instanceof import_zod7.z.ZodDate) {
+    jsonSchema.type = "string";
+    jsonSchema.format = "date-time";
+  }
+}, "dateOverride");
+var jsonSchemaOpts = {
+  unrepresentable: "any",
+  override: dateOverride
+};
+function isZodSchema(schema) {
+  return schema instanceof import_zod7.ZodObject;
+}
+__name(isZodSchema, "isZodSchema");
+var isNullableProperty = /* @__PURE__ */ __name((property) => {
+  const anyOf = property?.["anyOf"];
+  return Array.isArray(anyOf) && anyOf.some((s) => s?.["type"] === "null");
+}, "isNullableProperty");
+var dropNullableFromRequired = /* @__PURE__ */ __name((jsonSchema) => {
+  const { properties, required } = jsonSchema;
+  if (!properties || !Array.isArray(required)) return;
+  jsonSchema.required = required.filter((key) => !isNullableProperty(properties[key]));
+}, "dropNullableFromRequired");
+function toJsonSchema(schema) {
+  if (isZodSchema(schema)) {
+    const jsonSchema = (0, import_zod7.toJSONSchema)(schema, {
+      target: "openApi3",
+      ...jsonSchemaOpts
+    });
+    dropNullableFromRequired(jsonSchema);
+    return jsonSchema;
+  }
+  return schema;
+}
+__name(toJsonSchema, "toJsonSchema");
+var unwrap = /* @__PURE__ */ __name((schema) => {
+  let s = schema;
+  let t = s?._zod?.def?.type;
+  while (t === "optional" || t === "nullable" || t === "default" || t === "readonly") {
+    s = s._zod.def.innerType;
+    t = s?._zod?.def?.type;
+  }
+  return s;
+}, "unwrap");
+var typeOf = /* @__PURE__ */ __name((schema) => schema?._zod?.def?.type, "typeOf");
+function toSelectFields(schema) {
+  if (!isZodSchema(schema)) {
+    return Object.keys(schema.properties).reduce((acc, key) => {
+      acc[key] = true;
+      return acc;
+    }, {});
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(schema.shape)) {
+    const inner = unwrap(value);
+    const t = typeOf(inner);
+    if (t === "object") {
+      result[key] = {
+        select: toSelectFields(inner)
+      };
+      continue;
+    }
+    if (t === "array") {
+      const element = unwrap(inner._zod.def.element);
+      if (typeOf(element) === "object") {
+        result[key] = {
+          select: toSelectFields(element)
+        };
+        continue;
+      }
+    }
+    result[key] = true;
+  }
+  return result;
+}
+__name(toSelectFields, "toSelectFields");
+
+// src/lib/crud/write.repository.ts
+var import_common5 = require("@nestjs/common");
+
+// src/lib/crud/constants.ts
+var PRISMA_NOT_FOUND_CODE = "P2025";
+var DEFAULT_ID_FIELD = "id";
+
+// src/lib/crud/write.repository.ts
+var normalizeValueLabels = /* @__PURE__ */ __name((data, cols) => {
+  if (!data || typeof data !== "object" || Array.isArray(data) || !cols?.length) return data;
+  const out = {
+    ...data
+  };
+  for (const { field } of cols) {
+    if (field in out) out[field] = fromValueLabel(out[field]);
+  }
+  return out;
+}, "normalizeValueLabels");
+var includeRelationNames = /* @__PURE__ */ __name((include) => new Set((include ?? []).map((e) => typeof e === "string" ? e : e.relation)), "includeRelationNames");
+var WriteRepository = class {
+  static {
+    __name(this, "WriteRepository");
+  }
+  prismaModel;
+  prisma;
+  config;
+  constructor(prismaModel, prisma, config) {
+    this.prismaModel = prismaModel;
+    this.prisma = prisma;
+    this.config = config;
+  }
+  toId(id) {
+    return (this.config.idType ?? "string") === "number" ? +id : String(id);
+  }
+  notFound(id) {
+    return new import_common5.NotFoundException(`${this.config.name} with id ${id} not found`);
+  }
+  stripSubResourceKeys(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) return data;
+    const subKeys = new Set((this.config.subResources ?? []).map((s) => s.column));
+    if (!subKeys.size) return data;
+    return Object.fromEntries(Object.entries(data).filter(([k]) => !subKeys.has(k)));
+  }
+  stripNonCreateableChildFields(data, sub) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) return data;
+    const nonCreateable = new Set((sub.views?.form?.columns ?? []).filter((c) => c.createable === false).map((c) => c.id));
+    if (!nonCreateable.size) return data;
+    return Object.fromEntries(Object.entries(data).filter(([k]) => !nonCreateable.has(k)));
+  }
+  async prepare(data, op, id) {
+    const normalized = normalizeValueLabels(data, this.config.valueLabelColumns);
+    const hook = this.config.hooks?.beforeWrite;
+    return hook ? hook(normalized, {
+      prisma: this.prisma,
+      op,
+      id
+    }) : normalized;
+  }
+  async postWrite(result, op, id) {
+    const hook = this.config.hooks?.afterWrite;
+    return hook ? hook(result, {
+      prisma: this.prisma,
+      op,
+      id
+    }) : result;
+  }
+  upsertWhere(data) {
+    const keys = upsertOnFor(resolveDefinition(this.config));
+    if (!keys) throw new import_common5.BadRequestException(`${this.config.name} has no upsertOn configured`);
+    if (typeof keys === "string") return {
+      [keys]: data[keys]
+    };
+    const composite = keys.join("_");
+    return {
+      [composite]: Object.fromEntries(keys.map((k) => [
+        k,
+        data[k]
+      ]))
+    };
+  }
+  async create(data) {
+    const result = await this.prismaModel.create({
+      data: await this.prepare(this.stripSubResourceKeys(data), "create")
+    });
+    return this.postWrite(result, "create");
+  }
+  async update(id, data) {
+    const idField = this.config.idField ?? "id";
+    try {
+      const result = await this.prismaModel.update({
+        where: {
+          [idField]: this.toId(id)
+        },
+        data: await this.prepare(this.stripSubResourceKeys(data), "update", this.toId(id))
+      });
+      return this.postWrite(result, "update", this.toId(id));
+    } catch (e) {
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
+      throw e;
+    }
+  }
+  async upsert(data) {
+    const where = this.upsertWhere(data);
+    const existing = await this.prismaModel.findFirst({
+      where
+    });
+    const op = existing ? "update" : "create";
+    const prepared = await this.prepare(this.stripSubResourceKeys(data), op, existing ? existing[this.config.idField ?? DEFAULT_ID_FIELD] : void 0);
+    const result = await this.prismaModel.upsert({
+      where,
+      create: prepared,
+      update: prepared
+    });
+    return this.postWrite(result, op, existing ? existing[this.config.idField ?? DEFAULT_ID_FIELD] : void 0);
+  }
+  /** Upsert multiple rows in parallel. */
+  upsertMany(rows) {
+    return Promise.all(rows.map((r) => this.upsert(r)));
+  }
+  async delete(id) {
+    const idField = this.config.idField ?? "id";
+    try {
+      const result = await this.prismaModel.delete({
+        where: {
+          [idField]: this.toId(id)
+        }
+      });
+      return this.postWrite(result, "delete", this.toId(id));
+    } catch (e) {
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw this.notFound(id);
+      throw e;
+    }
+  }
+  /**
+  * Create a child record and attach it to the parent via the configured foreign key.
+  * Fields marked `createable: false` in the form view are stripped before writing.
+  */
+  async createChild(parentId, sub, data) {
+    const childModel = this.prisma[sub.childModel];
+    if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
+    const stripped = this.stripNonCreateableChildFields(data, sub);
+    const normalized = normalizeValueLabels(stripped, sub.valueLabelColumns);
+    const payload = {
+      ...normalized,
+      [sub.foreignKey]: this.toId(parentId)
+    };
+    const prepared = sub.hooks?.beforeWrite ? await sub.hooks.beforeWrite(payload, {
+      prisma: this.prisma,
+      op: "create"
+    }) : payload;
+    const includeKeys = includeRelationNames(sub.include);
+    const prismaData = {
+      ...Object.fromEntries(Object.entries(prepared).filter(([k]) => !includeKeys.has(k))),
+      [sub.foreignKey]: this.toId(parentId)
+    };
+    const result = await childModel.create({
+      data: prismaData
+    });
+    return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
+      prisma: this.prisma,
+      op: "create"
+    }) : result;
+  }
+  /**
+  * Update a child record. Relation include-keys are stripped from the payload so Prisma doesn't
+  * receive non-scalar fields.
+  * @throws {NotFoundException} When the child record does not exist (Prisma P2025).
+  */
+  async updateChild(sub, childId, data) {
+    const childModel = this.prisma[sub.childModel];
+    if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
+    const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
+    const normalized = normalizeValueLabels(data, sub.valueLabelColumns);
+    const afterHook = sub.hooks?.beforeWrite ? await sub.hooks.beforeWrite(normalized, {
+      prisma: this.prisma,
+      op: "update",
+      id
+    }) : normalized;
+    const includeKeys = includeRelationNames(sub.include);
+    const prepared = Object.fromEntries(Object.entries(afterHook).filter(([k]) => !includeKeys.has(k)));
+    try {
+      const result = await childModel.update({
+        where: {
+          [sub.idField ?? DEFAULT_ID_FIELD]: id
+        },
+        data: prepared
+      });
+      return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
+        prisma: this.prisma,
+        op: "update",
+        id
+      }) : result;
+    } catch (e) {
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      throw e;
+    }
+  }
+  /**
+  * Delete a child record. When `parentId` is supplied the foreign key is included in the `where`
+  * clause to prevent cross-parent deletions.
+  * @throws {NotFoundException} When no matching record is found.
+  */
+  async deleteChild(sub, childId, parentId) {
+    const childModel = this.prisma[sub.childModel];
+    if (!childModel) throw new Error(`Prisma model "${sub.childModel}" not found`);
+    const id = (sub.idType ?? "string") === "number" ? +childId : String(childId);
+    const idField = sub.idField ?? "id";
+    const where = {
+      [idField]: id
+    };
+    if (parentId !== void 0) where[sub.foreignKey] = this.toId(parentId);
+    try {
+      const result = await childModel.deleteMany({
+        where
+      });
+      if (result.count === 0) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      return sub.hooks?.afterWrite ? sub.hooks.afterWrite(result, {
+        prisma: this.prisma,
+        op: "delete",
+        id
+      }) : result;
+    } catch (e) {
+      if (e?.code === PRISMA_NOT_FOUND_CODE) throw new import_common5.NotFoundException(`${sub.childRoute} with id ${childId} not found`);
+      throw e;
+    }
+  }
+};
+
+// src/lib/crud/crud-repository.factory.ts
+function createCrudRepository(prisma, config) {
+  const model = prisma[config.model];
+  if (!model) {
+    throw new Error(`Model "${config.model}" not found on the provided PrismaClient. Check the resource config for "${config.name}".`);
+  }
+  const definition = resolveDefinition(config);
+  const listSchema = schemaFor(definition, "findAll");
+  const oneSchema = schemaFor(definition, "findOne");
+  const listSelect = listSchema ? toSelectFields(listSchema) : void 0;
+  const oneSelect = oneSchema ? toSelectFields(oneSchema) : listSelect;
+  const reader = new ReadRepository(model, prisma, config, listSelect, oneSelect);
+  const writer = new WriteRepository(model, prisma, config);
+  return {
+    prisma,
+    findAll: reader.findAll.bind(reader),
+    count: reader.count.bind(reader),
+    findOne: reader.findOne.bind(reader),
+    findAllByParent: reader.findAllByParent.bind(reader),
+    findOneChild: reader.findOneChild.bind(reader),
+    create: writer.create.bind(writer),
+    update: writer.update.bind(writer),
+    upsert: writer.upsert.bind(writer),
+    upsertMany: writer.upsertMany.bind(writer),
+    delete: writer.delete.bind(writer),
+    createChild: writer.createChild.bind(writer),
+    updateChild: writer.updateChild.bind(writer),
+    deleteChild: writer.deleteChild.bind(writer)
+  };
+}
+__name(createCrudRepository, "createCrudRepository");
+
+// src/lib/crud/data-source/data-source.registry.ts
+var import_common6 = require("@nestjs/common");
+function _ts_decorate4(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var DataSourceRegistry = class {
+  static {
+    __name(this, "DataSourceRegistry");
+  }
+  clients = /* @__PURE__ */ new Map();
+  defaultName;
+  constructor(entries) {
+    for (const entry of entries) {
+      this.clients.set(entry.config.name, entry.client);
+      if (entry.config.default) {
+        this.defaultName = entry.config.name;
+      }
+    }
+    if (!this.defaultName && entries.length > 0) {
+      this.defaultName = entries[0].config.name;
+    }
+  }
+  get(name) {
+    const client = this.clients.get(name);
+    if (!client) {
+      throw new Error(`Data source "${name}" not found in registry`);
+    }
+    return client;
+  }
+  getDefault() {
+    if (!this.defaultName) {
+      throw new Error("No default data source configured");
+    }
+    return this.get(this.defaultName);
+  }
+  resolve(database) {
+    return database ? this.get(database) : this.getDefault();
+  }
+  async onModuleDestroy() {
+    for (const client of this.clients.values()) {
+      if (typeof client.$disconnect === "function") {
+        await client.$disconnect();
+      }
+    }
+  }
+};
+DataSourceRegistry = _ts_decorate4([
+  (0, import_common6.Injectable)(),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    Array
+  ])
+], DataSourceRegistry);
+
+// src/lib/crud/data-source/data-source.loader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var loadDataSourcesFromDir = /* @__PURE__ */ __name(async (dirPath) => {
+  if (!(0, import_node_fs.existsSync)(dirPath)) return [];
+  const entries = (0, import_node_fs.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");
+    if (!indexFile) continue;
+    const mod = await import(indexFile);
+    const client = mod.default;
+    if (!client) continue;
+    results.push({
+      config,
+      client
+    });
+  }
+  return results;
+}, "loadDataSourcesFromDir");
+var findModule = /* @__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;
+  }
+  return void 0;
+}, "findModule");
+
+// src/lib/crud/operations/register-actions.ts
+var import_common7 = require("@nestjs/common");
+var import_swagger2 = require("@nestjs/swagger");
+
+// src/lib/crud/operations/decorator.utils.ts
+var def = /* @__PURE__ */ __name((cls, method, fn) => {
+  Object.defineProperty(cls.prototype, method, {
+    value: fn,
+    writable: true,
+    configurable: true
+  });
+}, "def");
+var desc = /* @__PURE__ */ __name((cls, method) => Object.getOwnPropertyDescriptor(cls.prototype, method), "desc");
+
+// src/lib/crud/operations/register-actions.ts
+var registerActionRoutes = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config } = ctx;
+  const { name } = config;
+  const procedureActions = (config.actions ?? []).filter((a) => a.type !== "link");
+  for (const action of procedureActions) {
+    const methodName = `procedure_${action.id}`;
+    def(cls, methodName, async function(recordId) {
+      return action.procedure(this.repo.prisma, recordId);
+    });
+    const d = desc(cls, methodName);
+    (0, import_common7.Post)(`procedure/${action.id}/:recordId`)(cls.prototype, methodName, d);
+    (0, import_common7.Param)("recordId")(cls.prototype, methodName, 0);
+    (0, import_swagger2.ApiOperation)({
+      summary: `Execute action "${action.label}" on a ${name}`
+    })(cls.prototype, methodName, d);
+    (0, import_swagger2.ApiParam)({
+      name: "recordId",
+      type: "string"
+    })(cls.prototype, methodName, d);
+    (0, import_swagger2.ApiResponse)({
+      status: 200,
+      description: `Action "${action.id}" result`
+    })(cls.prototype, methodName, d);
+  }
+}, "registerActionRoutes");
+var registerTableActionRoutes = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config } = ctx;
+  const { name } = config;
+  const procedureActions = (config.tableActions ?? []).filter((a) => a.type !== "link");
+  for (const action of procedureActions) {
+    const methodName = `tableAction_${action.id}`;
+    def(cls, methodName, async function() {
+      return action.procedure(this.repo.prisma);
+    });
+    const d = desc(cls, methodName);
+    (0, import_common7.Post)(`table-action/${action.id}`)(cls.prototype, methodName, d);
+    (0, import_swagger2.ApiOperation)({
+      summary: `Execute table action "${action.label ?? action.id}" on ${name}`
+    })(cls.prototype, methodName, d);
+    (0, import_swagger2.ApiResponse)({
+      status: 200,
+      description: `Table action "${action.id}" result`
+    })(cls.prototype, methodName, d);
+  }
+}, "registerTableActionRoutes");
+
+// src/lib/crud/operations/register-crud.ts
+var import_common8 = require("@nestjs/common");
+var import_swagger3 = require("@nestjs/swagger");
+
+// src/lib/crud/request.dto.ts
+var import_zod_nestjs = require("@anatine/zod-nestjs");
+var RequestDtoNoOffset = class extends (0, import_zod_nestjs.createZodDto)(RequestSchema) {
+  static {
+    __name(this, "RequestDtoNoOffset");
+  }
+};
+var RequestDto = class extends (0, import_zod_nestjs.createZodDto)(RequestSchemaWithOffset) {
+  static {
+    __name(this, "RequestDto");
+  }
+};
+
+// src/lib/crud/zod-validation.pipe.ts
+var ZodValidationPipe = class {
+  static {
+    __name(this, "ZodValidationPipe");
+  }
+  schema;
+  /** Top-level field names that accept `null` (i.e. are nullable). */
+  nullableKeys;
+  /** Whether to coerce `undefined` → `null` on nullable fields (create/upsert only). */
+  coerceUndefinedToNull;
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.nullableKeys = Object.entries(schema.shape).filter(([, field]) => field.safeParse(null).success).map(([key]) => key);
+    this.coerceUndefinedToNull = options.coerceNullableUndefinedToNull ?? false;
+  }
+  transform(value) {
+    const stripped = this.stripEmptyStrings(value);
+    const input = this.coerceNullable(stripped);
+    const result = this.schema.safeParse(input);
+    if (!result.success) {
+      throw new CroutonValidationError(this.formatErrors(result.error));
+    }
+    return result.data;
+  }
+  /**
+  * Convert empty strings (`''`) on all top-level fields:
+  * - Nullable fields (`z.string().nullable()`): `""` → `null`
+  *   (clearing a nullable field should store null, not fail validation)
+  * - Required/optional fields (`z.string()` / `z.string().optional()`): `""` → `undefined`
+  *   (required → fails with invalid_type; optional → passes as absent)
+  */
+  stripEmptyStrings(value) {
+    if (value == null || typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const out = {
+      ...value
+    };
+    for (const key of Object.keys(out)) {
+      if (out[key] === "") {
+        out[key] = this.nullableKeys.includes(key) ? null : void 0;
+      }
+    }
+    return out;
+  }
+  /** Replace `undefined` with `null` on nullable fields (create/upsert only). */
+  coerceNullable(value) {
+    if (!this.coerceUndefinedToNull || value == null || typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const out = {
+      ...value
+    };
+    for (const key of this.nullableKeys) {
+      if (out[key] === void 0) out[key] = null;
+    }
+    return out;
+  }
+  formatErrors(error) {
+    return error.issues.map((e) => ({
+      field: e.path.join("."),
+      message: e.message
+    }));
+  }
+};
+
+// src/lib/crud/operations/register-crud.ts
+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
+      }
+    };
+  });
+  const d = desc(cls, "findAll");
+  (0, import_common8.Get)()(cls.prototype, "findAll", d);
+  (0, import_common8.Query)(new ZodValidationPipe(RequestDtoNoOffset.zodSchema))(cls.prototype, "findAll", 0);
+  (0, import_common8.Query)("q")(cls.prototype, "findAll", 1);
+  (0, import_swagger3.ApiOperation)({
+    summary: `List all ${name}s`
+  })(cls.prototype, "findAll", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 200,
+    description: `Array of ${name}`,
+    ...listSchema && {
+      schema: {
+        type: "array",
+        items: toJsonSchema(listSchema)
+      }
+    }
+  })(cls.prototype, "findAll", d);
+}, "registerFindAll");
+var registerFindOne = /* @__PURE__ */ __name((ctx) => {
+  if (!isOperationEnabled(ctx.definition, "findOne")) return;
+  const { cls, config, oneSchema, idParamMeta } = ctx;
+  const { name } = config;
+  def(cls, "findOne", function(id) {
+    return this.repo.findOne(id);
+  });
+  const d = desc(cls, "findOne");
+  (0, import_common8.Get)(":id")(cls.prototype, "findOne", d);
+  (0, import_common8.Param)("id")(cls.prototype, "findOne", 0);
+  (0, import_swagger3.ApiOperation)({
+    summary: `Get one ${name} by id`
+  })(cls.prototype, "findOne", d);
+  (0, import_swagger3.ApiParam)(idParamMeta)(cls.prototype, "findOne", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 200,
+    description: `The ${name}`,
+    ...oneSchema && {
+      schema: toJsonSchema(oneSchema)
+    }
+  })(cls.prototype, "findOne", d);
+  (0, import_swagger3.ApiNotFoundResponse)({
+    description: "Not found"
+  })(cls.prototype, "findOne", d);
+}, "registerFindOne");
+var registerCreate = /* @__PURE__ */ __name((ctx) => {
+  if (!isOperationEnabled(ctx.definition, "create")) return;
+  const { cls, config, createSchema, bodyDecorator } = ctx;
+  const { name } = config;
+  def(cls, "create", function(body) {
+    return this.repo.create(body);
+  });
+  const d = desc(cls, "create");
+  (0, import_common8.Post)()(cls.prototype, "create", d);
+  bodyDecorator(createSchema, {
+    coerceNullableUndefinedToNull: true
+  })(cls.prototype, "create", 0);
+  (0, import_swagger3.ApiOperation)({
+    summary: `Create a ${name}`
+  })(cls.prototype, "create", d);
+  if (createSchema) (0, import_swagger3.ApiBody)({
+    schema: toJsonSchema(createSchema)
+  })(cls.prototype, "create", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 201,
+    description: `${name} created`
+  })(cls.prototype, "create", d);
+}, "registerCreate");
+var registerUpdate = /* @__PURE__ */ __name((ctx) => {
+  if (!isOperationEnabled(ctx.definition, "update")) return;
+  const { cls, config, updateSchema, idParamMeta, bodyDecorator } = ctx;
+  const { name } = config;
+  def(cls, "update", function(id, body) {
+    return this.repo.update(id, body);
+  });
+  const d = desc(cls, "update");
+  (0, import_common8.Patch)(":id")(cls.prototype, "update", d);
+  (0, import_common8.Param)("id")(cls.prototype, "update", 0);
+  bodyDecorator(updateSchema)(cls.prototype, "update", 1);
+  (0, import_swagger3.ApiOperation)({
+    summary: `Update a ${name}`
+  })(cls.prototype, "update", d);
+  (0, import_swagger3.ApiParam)(idParamMeta)(cls.prototype, "update", d);
+  if (updateSchema) (0, import_swagger3.ApiBody)({
+    schema: toJsonSchema(updateSchema)
+  })(cls.prototype, "update", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 200,
+    description: `${name} updated`
+  })(cls.prototype, "update", d);
+  (0, import_swagger3.ApiNotFoundResponse)({
+    description: "Not found"
+  })(cls.prototype, "update", d);
+}, "registerUpdate");
+var registerUpsert = /* @__PURE__ */ __name((ctx) => {
+  if (!isOperationEnabled(ctx.definition, "upsert")) return;
+  const { cls, config, upsertSchema, bodyDecorator } = ctx;
+  const { name } = config;
+  def(cls, "upsert", function(body) {
+    return this.repo.upsert(body);
+  });
+  const d = desc(cls, "upsert");
+  (0, import_common8.Put)()(cls.prototype, "upsert", d);
+  bodyDecorator(upsertSchema, {
+    coerceNullableUndefinedToNull: true
+  })(cls.prototype, "upsert", 0);
+  (0, import_swagger3.ApiOperation)({
+    summary: `Upsert a ${name}`
+  })(cls.prototype, "upsert", d);
+  if (upsertSchema) (0, import_swagger3.ApiBody)({
+    schema: toJsonSchema(upsertSchema)
+  })(cls.prototype, "upsert", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 200,
+    description: `${name} upserted`
+  })(cls.prototype, "upsert", d);
+}, "registerUpsert");
+var registerDelete = /* @__PURE__ */ __name((ctx) => {
+  if (!isOperationEnabled(ctx.definition, "delete")) return;
+  const { cls, config, idParamMeta } = ctx;
+  const { name } = config;
+  def(cls, "delete", function(id) {
+    return this.repo.delete(id);
+  });
+  const d = desc(cls, "delete");
+  (0, import_common8.Delete)(":id")(cls.prototype, "delete", d);
+  (0, import_common8.Param)("id")(cls.prototype, "delete", 0);
+  (0, import_swagger3.ApiOperation)({
+    summary: `Delete a ${name}`
+  })(cls.prototype, "delete", d);
+  (0, import_swagger3.ApiParam)(idParamMeta)(cls.prototype, "delete", d);
+  (0, import_swagger3.ApiResponse)({
+    status: 200,
+    description: `${name} deleted`
+  })(cls.prototype, "delete", d);
+  (0, import_swagger3.ApiNotFoundResponse)({
+    description: "Not found"
+  })(cls.prototype, "delete", d);
+}, "registerDelete");
+
+// src/lib/crud/operations/register-schema-endpoints.ts
+var import_common9 = require("@nestjs/common");
+var import_swagger4 = require("@nestjs/swagger");
+
+// src/lib/crud/operations/payload-builders.ts
+var resolveEnvPlaceholders = /* @__PURE__ */ __name((value) => value.replace(/\{env\.([^}]+)\}/g, (match, varName) => process.env[varName] ?? match), "resolveEnvPlaceholders");
+var buildSubResourceOperations = /* @__PURE__ */ __name((ops, baseUri, idField = "id") => {
+  if (!ops) return {};
+  const idPlaceholder = `{${idField}}`;
+  return {
+    ...ops.findAll && {
+      findAll: {
+        uri: baseUri,
+        method: "get"
+      }
+    },
+    ...ops.findOne && {
+      findOne: {
+        uri: `${baseUri}/${idPlaceholder}`,
+        method: "get"
+      }
+    },
+    ...ops.create && {
+      create: {
+        uri: baseUri,
+        method: "post"
+      }
+    },
+    ...ops.update && {
+      update: {
+        uri: `${baseUri}/${idPlaceholder}`,
+        method: "patch"
+      }
+    },
+    ...ops.delete && {
+      delete: {
+        uri: `${baseUri}/${idPlaceholder}`,
+        method: "delete"
+      }
+    }
+  };
+}, "buildSubResourceOperations");
+var RESOURCE_OPS = [
+  "findAll",
+  "findOne",
+  "create",
+  "update",
+  "delete"
+];
+var OP_METHOD = {
+  findAll: "get",
+  findOne: "get",
+  create: "post",
+  update: "patch",
+  delete: "delete"
+};
+var OP_SUFFIX = {
+  findAll: "",
+  findOne: "/{id}",
+  create: "",
+  update: "/{id}",
+  delete: "/{id}"
+};
+var buildResourceOperations = /* @__PURE__ */ __name((definition, baseUri) => Object.fromEntries(RESOURCE_OPS.filter((op) => isOperationEnabled(definition, op)).map((op) => [
+  op,
+  {
+    uri: `${baseUri}${OP_SUFFIX[op]}`,
+    method: OP_METHOD[op]
+  }
+])), "buildResourceOperations");
+var buildDefinitionPayload = /* @__PURE__ */ __name((config) => {
+  const { route, name, tag, idType = "string" } = config;
+  const definition = resolveDefinition(config);
+  const listSchema = schemaFor(definition, "findAll");
+  const oneSchema = schemaFor(definition, "findOne") ?? listSchema;
+  const createSchema = schemaFor(definition, "create");
+  const updateSchema = schemaFor(definition, "update");
+  const upsertSchema = schemaFor(definition, "upsert") ?? createSchema;
+  const operations = [
+    "findAll",
+    "findOne",
+    "create",
+    "update",
+    "upsert",
+    "delete"
+  ].filter((op) => isOperationEnabled(definition, op));
+  return {
+    name,
+    route,
+    idType,
+    tag,
+    operations,
+    upsertOn: upsertOnFor(definition),
+    schemas: {
+      ...listSchema && {
+        findAll: toJsonSchema(listSchema)
+      },
+      ...oneSchema && {
+        findOne: toJsonSchema(oneSchema)
+      },
+      ...createSchema && {
+        create: toJsonSchema(createSchema)
+      },
+      ...updateSchema && {
+        update: toJsonSchema(updateSchema)
+      },
+      ...isOperationEnabled(definition, "upsert") && upsertSchema ? {
+        upsert: toJsonSchema(upsertSchema)
+      } : {}
+    }
+  };
+}, "buildDefinitionPayload");
+var buildResourceJsonPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+  const { name, route } = config;
+  const definition = resolveDefinition(config);
+  const uri = `${baseUrl}/${route}`;
+  const operations = Object.fromEntries(RESOURCE_OPS.map((op) => [
+    op,
+    isOperationEnabled(definition, op)
+  ]));
+  operations.lookup = `${uri}?q={text}`;
+  const form = config.views?.["form"];
+  const schema = form?.json_schema ? {
+    data: form.json_schema,
+    ui: form.ui_schema
+  } : null;
+  return {
+    id: name,
+    uri,
+    operations,
+    schema
+  };
+}, "buildResourceJsonPayload");
+var buildViewsPayload = /* @__PURE__ */ __name((config, baseUrl) => {
+  if (!config.views || !Object.keys(config.views).length) return void 0;
+  const definition = resolveDefinition(config);
+  const baseUri = `${baseUrl}/${config.route}`;
+  const operations = buildResourceOperations(definition, baseUri);
+  if (isOperationEnabled(definition, "findAll")) {
+    operations["lookup"] = `${baseUri}?q={text}`;
+  }
+  const schemas = Object.fromEntries(Object.entries(config.views).map(([key, v]) => [
+    key,
+    {
+      data: v.json_schema,
+      ui: v.ui_schema,
+      ...v.defaultSort !== void 0 && {
+        defaultSort: v.defaultSort
+      }
+    }
+  ]));
+  return {
+    id: config.name,
+    name: config.name,
+    route: config.route,
+    uri: `${baseUrl}/${config.route}`,
+    title: config.title ?? config.tag,
+    idField: config.lookup?.key ?? "id",
+    idType: config.idType ?? "string",
+    ...config.modalSize && {
+      modalSize: config.modalSize
+    },
+    operations,
+    display: config.display,
+    schemas,
+    ...config.actions?.length && {
+      actions: config.actions.map((a) => a.type === "link" ? {
+        type: "link",
+        id: a.id,
+        label: a.label,
+        href: resolveEnvPlaceholders(a.href),
+        ...a.condition && {
+          condition: a.condition
+        }
+      } : {
+        id: a.id,
+        label: a.label,
+        uri: `${baseUrl}/${config.route}/procedure/${a.id}/{id}`,
+        method: a.method ?? "post",
+        ...a.data && {
+          data: a.data
+        },
+        ...a.condition && {
+          condition: a.condition
+        }
+      })
+    },
+    ...config.tableActions?.length && {
+      tableActions: config.tableActions.map((a) => a.type === "link" ? {
+        type: "link",
+        id: a.id,
+        label: a.label,
+        icon: a.icon,
+        tooltip: a.tooltip,
+        href: resolveEnvPlaceholders(a.href)
+      } : {
+        id: a.id,
+        label: a.label,
+        icon: a.icon,
+        tooltip: a.tooltip,
+        uri: `${baseUrl}/${config.route}/table-action/${a.id}`,
+        method: a.method ?? "post",
+        ...a.data && {
+          data: a.data
+        }
+      })
+    }
+  };
+}, "buildViewsPayload");
+
+// src/lib/crud/operations/register-schema-endpoints.ts
+var registerDefinitionEndpoint = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config } = ctx;
+  const { route, name } = config;
+  const definitionPayload = buildDefinitionPayload(config);
+  def(cls, "getDefinition", async function() {
+    if (IS_DEV) {
+      const fresh = await this.configRegistry.getByRoute(route);
+      if (fresh) return buildDefinitionPayload(fresh);
+    }
+    return definitionPayload;
+  });
+  const d = desc(cls, "getDefinition");
+  (0, import_common9.Get)("definition")(cls.prototype, "getDefinition", d);
+  (0, import_swagger4.ApiOperation)({
+    summary: `Get the resource definition for ${name}`
+  })(cls.prototype, "getDefinition", d);
+  (0, import_swagger4.ApiResponse)({
+    status: 200,
+    description: `Definition (operations + schemas) for ${name}`
+  })(cls.prototype, "getDefinition", d);
+}, "registerDefinitionEndpoint");
+var registerSchemasEndpoint = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config, baseUrl } = ctx;
+  const { route, name } = config;
+  const viewsPayload = buildViewsPayload(config, baseUrl);
+  def(cls, "getSchemas", async function() {
+    if (IS_DEV) {
+      const fresh = await this.configRegistry.getByRoute(route);
+      if (fresh) return buildViewsPayload(fresh, baseUrl) ?? viewsPayload;
+    }
+    return viewsPayload;
+  });
+  const d = desc(cls, "getSchemas");
+  (0, import_common9.Get)("schemas")(cls.prototype, "getSchemas", d);
+  (0, import_swagger4.ApiOperation)({
+    summary: `Get view schemas (table/form) for ${name}`
+  })(cls.prototype, "getSchemas", d);
+  (0, import_swagger4.ApiResponse)({
+    status: 200,
+    description: `View schemas for ${name}`
+  })(cls.prototype, "getSchemas", d);
+}, "registerSchemasEndpoint");
+var registerResourceJsonEndpoint = /* @__PURE__ */ __name((ctx) => {
+  const { cls, config, baseUrl } = ctx;
+  const { route, name } = config;
+  const resourceJsonPayload = buildResourceJsonPayload(config, baseUrl);
+  def(cls, "getResourceJson", async function() {
+    if (IS_DEV) {
+      const fresh = await this.configRegistry.getByRoute(route);
+      if (fresh) return buildResourceJsonPayload(fresh, baseUrl);
+    }
+    return resourceJsonPayload;
+  });
+  const d = desc(cls, "getResourceJson");
+  (0, import_common9.Get)("resource.json")(cls.prototype, "getResourceJson", d);
+  (0, import_swagger4.ApiOperation)({
+    summary: `Get resource descriptor for ${name}`
+  })(cls.prototype, "getResourceJson", d);
+  (0, import_swagger4.ApiResponse)({
+    status: 200,
+    description: `Resource descriptor (operations + JSON Schema) for ${name}`
+  })(cls.prototype, "getResourceJson", d);
+}, "registerResourceJsonEndpoint");
+
+// src/lib/crud/operations/register-sub-resources.ts
+var import_common10 = require("@nestjs/common");
+var import_swagger5 = require("@nestjs/swagger");
+var registerSubResourceSchemas = /* @__PURE__ */ __name((ctx, sub) => {
+  if (!sub.views) return;
+  const { cls, config, baseUrl } = ctx;
+  const { route } = config;
+  const methodName = `getSchemas_${sub.childRoute}`;
+  const childUri = `${baseUrl}/${route}/{parent.id}/${sub.childRoute}`;
+  const schemasPayload = {
+    id: sub.name ?? sub.childRoute,
+    name: sub.name ?? sub.childRoute,
+    route: sub.childRoute,
+    uri: childUri,
+    title: sub.title ?? sub.childRoute,
+    idField: sub.idField ?? "id",
+    idType: sub.idType ?? "string",
+    ...sub.modalSize && {
+      modalSize: sub.modalSize
+    },
+    operations: buildSubResourceOperations(sub.operations, childUri, sub.idField ?? "id"),
+    schemas: Object.fromEntries(Object.entries(sub.views).map(([key, v]) => [
+      key,
+      {
+        data: v.json_schema,
+        ui: v.ui_schema,
+        ...v.defaultSort !== void 0 && {
+          defaultSort: v.defaultSort
+        }
+      }
+    ])),
+    ...sub.actions?.length && {
+      actions: sub.actions.map((a) => a.type === "link" ? {
+        type: "link",
+        id: a.id,
+        label: a.label,
+        href: resolveEnvPlaceholders(a.href),
+        ...a.condition && {
+          condition: a.condition
+        }
+      } : {
+        id: a.id,
+        label: a.label,
+        uri: `${baseUrl}/${sub.childRoute}/procedure/${a.id}/{id}`,
+        method: a.method ?? "post",
+        ...a.data && {
+          data: a.data
+        },
+        ...a.condition && {
+          condition: a.condition
+        }
+      })
+    }
+  };
+  def(cls, methodName, async function() {
+    return schemasPayload;
+  });
+  const ds = desc(cls, methodName);
+  (0, import_common10.Get)(`${sub.childRoute}/schemas`)(cls.prototype, methodName, ds);
+  (0, import_swagger5.ApiOperation)({
+    summary: `Get schemas for ${sub.childRoute}`
+  })(cls.prototype, methodName, ds);
+  (0, import_swagger5.ApiResponse)({
+    status: 200,
+    description: `View schemas for ${sub.childRoute}`
+  })(cls.prototype, methodName, ds);
+}, "registerSubResourceSchemas");
+var registerSubResourceFindAll = /* @__PURE__ */ __name((ctx, sub) => {
+  if (sub.operations?.findAll === false) return;
+  const { cls, config } = ctx;
+  const { name } = config;
+  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
+      }
+    };
+  });
+  const d = desc(cls, methodName);
+  (0, import_common10.Get)(`:id/${sub.childRoute}`)(cls.prototype, methodName, d);
+  (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common10.Query)(new ZodValidationPipe(RequestDtoNoOffset.zodSchema))(cls.prototype, methodName, 1);
+  (0, import_swagger5.ApiOperation)({
+    summary: `List ${sub.childRoute} for a ${name}`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiParam)(idParamMeta)(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiResponse)({
+    status: 200,
+    description: `${sub.childRoute} list`
+  })(cls.prototype, methodName, d);
+}, "registerSubResourceFindAll");
+var registerSubResourceCreate = /* @__PURE__ */ __name((ctx, sub) => {
+  if (!sub.operations?.create) return;
+  const { cls, config } = ctx;
+  const { name } = config;
+  const methodName = `createChild_${sub.childRoute}`;
+  def(cls, methodName, async function(id, body) {
+    return this.repo.createChild(id, sub, body);
+  });
+  const d = desc(cls, methodName);
+  (0, import_common10.Post)(`:id/${sub.childRoute}`)(cls.prototype, methodName, d);
+  (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common10.Body)()(cls.prototype, methodName, 1);
+  (0, import_swagger5.ApiOperation)({
+    summary: `Create ${sub.childRoute} for a ${name}`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiParam)(ctx.idParamMeta)(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiResponse)({
+    status: 201,
+    description: `${sub.childRoute} created`
+  })(cls.prototype, methodName, d);
+}, "registerSubResourceCreate");
+var registerSubResourceFindOne = /* @__PURE__ */ __name((ctx, sub) => {
+  if (!sub.operations?.findOne) return;
+  const { cls } = ctx;
+  const methodName = `findOneChild_${sub.childRoute}`;
+  def(cls, methodName, async function(parentId, childId) {
+    return this.repo.findOneChild(sub, childId, parentId);
+  });
+  const d = desc(cls, methodName);
+  (0, import_common10.Get)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
+  (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common10.Param)("childId")(cls.prototype, methodName, 1);
+  (0, import_swagger5.ApiOperation)({
+    summary: `Get a ${sub.childRoute} record`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiParam)(ctx.idParamMeta)(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiResponse)({
+    status: 200,
+    description: `${sub.childRoute} record`
+  })(cls.prototype, methodName, d);
+}, "registerSubResourceFindOne");
+var registerSubResourceUpdate = /* @__PURE__ */ __name((ctx, sub) => {
+  if (!sub.operations?.update) return;
+  const { cls } = ctx;
+  const methodName = `updateChild_${sub.childRoute}`;
+  def(cls, methodName, async function(_id, childId, body) {
+    return this.repo.updateChild(sub, childId, body);
+  });
+  const d = desc(cls, methodName);
+  (0, import_common10.Patch)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
+  (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common10.Param)("childId")(cls.prototype, methodName, 1);
+  (0, import_common10.Body)()(cls.prototype, methodName, 2);
+  (0, import_swagger5.ApiOperation)({
+    summary: `Update a ${sub.childRoute} record`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiParam)(ctx.idParamMeta)(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiResponse)({
+    status: 200,
+    description: `${sub.childRoute} updated`
+  })(cls.prototype, methodName, d);
+}, "registerSubResourceUpdate");
+var registerSubResourceDelete = /* @__PURE__ */ __name((ctx, sub) => {
+  if (!sub.operations?.delete) return;
+  const { cls } = ctx;
+  const methodName = `deleteChild_${sub.childRoute}`;
+  def(cls, methodName, async function(parentId, childId) {
+    return this.repo.deleteChild(sub, childId, parentId);
+  });
+  const d = desc(cls, methodName);
+  (0, import_common10.Delete)(`:id/${sub.childRoute}/:childId`)(cls.prototype, methodName, d);
+  (0, import_common10.Param)("id")(cls.prototype, methodName, 0);
+  (0, import_common10.Param)("childId")(cls.prototype, methodName, 1);
+  (0, import_swagger5.ApiOperation)({
+    summary: `Delete ${sub.childRoute} record`
+  })(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiParam)(ctx.idParamMeta)(cls.prototype, methodName, d);
+  (0, import_swagger5.ApiResponse)({
+    status: 200,
+    description: `${sub.childRoute} deleted`
+  })(cls.prototype, methodName, d);
+}, "registerSubResourceDelete");
+var registerSubResourceRoutes = /* @__PURE__ */ __name((ctx) => {
+  for (const sub of ctx.config.subResources ?? []) {
+    registerSubResourceSchemas(ctx, sub);
+    registerSubResourceFindAll(ctx, sub);
+    registerSubResourceCreate(ctx, sub);
+    registerSubResourceFindOne(ctx, sub);
+    registerSubResourceUpdate(ctx, sub);
+    registerSubResourceDelete(ctx, sub);
+  }
+}, "registerSubResourceRoutes");
+
+// src/lib/crud/crud-controller.factory.ts
+function createCrudController(config, baseUrl) {
+  const { route, name, tag, idType = "string" } = config;
+  const definition = resolveDefinition(config);
+  const listSchema = schemaFor(definition, "findAll");
+  const oneSchema = schemaFor(definition, "findOne") ?? listSchema;
+  const createSchema = schemaFor(definition, "create");
+  const updateSchema = schemaFor(definition, "update");
+  const upsertSchema = schemaFor(definition, "upsert") ?? createSchema;
+  if (isOperationEnabled(definition, "upsert") && !upsertOnFor(definition)) {
+    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)();
+  }, "bodyDecorator");
+  let CrudControllerBase = class CrudControllerBase {
+    static {
+      __name(this, "CrudControllerBase");
+    }
+    repo;
+    configRegistry;
+    constructor(registry, configRegistry) {
+      const prisma = registry.resolve(config.database);
+      this.repo = createCrudRepository(prisma, config);
+      this.configRegistry = configRegistry;
+    }
+  };
+  const ctx = {
+    cls: CrudControllerBase,
+    config,
+    definition,
+    listSchema,
+    oneSchema,
+    createSchema,
+    updateSchema,
+    upsertSchema,
+    idParamMeta: {
+      name: "id",
+      type: idType === "number" ? "number" : "string"
+    },
+    bodyDecorator,
+    baseUrl
+  };
+  registerFindAll(ctx);
+  registerDefinitionEndpoint(ctx);
+  registerSchemasEndpoint(ctx);
+  registerResourceJsonEndpoint(ctx);
+  registerActionRoutes(ctx);
+  registerTableActionRoutes(ctx);
+  registerSubResourceRoutes(ctx);
+  registerFindOne(ctx);
+  registerCreate(ctx);
+  registerUpdate(ctx);
+  registerUpsert(ctx);
+  registerDelete(ctx);
+  (0, import_common11.Controller)(route)(CrudControllerBase);
+  (0, import_swagger6.ApiTags)(tag)(CrudControllerBase);
+  Object.defineProperty(CrudControllerBase, "name", {
+    value: `${name.charAt(0).toUpperCase() + name.slice(1)}Controller`
+  });
+  Reflect.defineMetadata("design:paramtypes", [
+    DataSourceRegistry,
+    ResourceConfigRegistry
+  ], CrudControllerBase);
+  return CrudControllerBase;
+}
+__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;
+  }
+  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/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;
+    }
+    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
+    });
+  }
+  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;
+    }
+  }
+  if (!file || !(0, import_node_fs3.existsSync)(file)) return {};
+  try {
+    return JSON.parse((0, import_node_fs3.readFileSync)(file, "utf-8"));
+  } catch {
+    return {};
+  }
+}, "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;
+  }
+}, "injectEnumValues");
+
+// src/lib/crud/loader/json-adapter.ts
+var import_zod9 = require("zod");
+
+// src/lib/crud/loader/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 filtered = columns.filter(baseFilter);
+  if (!filtered.length) return void 0;
+  const mask = Object.fromEntries(filtered.map((c) => [
+    c.id,
+    true
+  ]));
+  return schema.pick(mask);
+}, "pickByColumns");
+var opWithSchema = /* @__PURE__ */ __name((enabled, schema) => {
+  if (enabled === false) return void 0;
+  return schema ? {
+    schema
+  } : true;
+}, "opWithSchema");
+var upsertOp = /* @__PURE__ */ __name((entry, schema) => {
+  if (!entry) return void 0;
+  if (entry === true) {
+    throw new Error("`operations.upsert` must be an object with `upsertOn`, not `true`.");
+  }
+  if (typeof entry === "object") {
+    return {
+      upsertOn: entry.upsertOn,
+      ...schema && {
+        schema
+      }
+    };
+  }
+  return void 0;
+}, "upsertOp");
+
+// src/lib/crud/loader/view.builders.ts
+var import_zod8 = require("zod");
+
+// src/lib/crud/loader/form-schema.builder.ts
+var buildConditionSchema = /* @__PURE__ */ __name((when) => {
+  if (when.notExists) return {
+    not: {
+      minLength: 1
+    }
+  };
+  if (when.exists) return {
+    minLength: 1
+  };
+  if (when.neq !== void 0) return {
+    not: {
+      const: when.neq
+    }
+  };
+  return {
+    const: when.eq
+  };
+}, "buildConditionSchema");
+var buildRule = /* @__PURE__ */ __name((col) => {
+  if (col.disabledWhen) {
+    return {
+      effect: "DISABLE",
+      condition: {
+        scope: `#/properties/${col.disabledWhen.field}`,
+        schema: buildConditionSchema(col.disabledWhen)
+      }
+    };
+  }
+  const when = col.showWhen ?? col.hideWhen;
+  if (!when) return void 0;
+  const effect = col.showWhen ? "SHOW" : "HIDE";
+  return {
+    effect,
+    condition: {
+      scope: `#/properties/${when.field}`,
+      schema: buildConditionSchema(when)
+    }
+  };
+}, "buildRule");
+var buildDetailLayout = /* @__PURE__ */ __name((detail) => {
+  const inner = detail.layout === "collapse" ? LayoutBuilder.collapse() : LayoutBuilder.horizontal();
+  inner.addControls(...detail.controls.map((dc) => {
+    const ctrl = ControlBuilder.properties(dc.property);
+    if (dc.type === "markdown") {
+      ctrl.markdown(dc.options);
+    } else if (dc.type) {
+      ctrl.control(dc.type, dc.options ?? {});
+    }
+    if (dc.hideLabel) ctrl.hideLabel();
+    if (dc.width) ctrl.width(dc.width);
+    return ctrl;
+  }));
+  if (detail.titleKey) inner.titleKey(detail.titleKey);
+  return inner;
+}, "buildDetailLayout");
+var buildFormControl = /* @__PURE__ */ __name((col) => {
+  const control = ControlBuilder.properties(col.id);
+  const fieldInput = col.fieldInput;
+  if (fieldInput?.format === "relation") {
+    const options = {
+      ...fieldInput.options
+    };
+    if (!options.colspan) options.colspan = 12;
+    if (fieldInput.relationType) options.relationType = fieldInput.relationType;
+    control.control("relation", options).width("full");
+  } else if (fieldInput?.type === "autocomplete") {
+    const options = {
+      ...fieldInput.options
+    };
+    if (!options.colspan) options.colspan = 12;
+    if (fieldInput.relationType) options.relationType = fieldInput.relationType;
+    const format = fieldInput.format ?? fieldInput.type;
+    control.control(format, options).width("full");
+  } else if (fieldInput?.detail) {
+    const detailLayout = buildDetailLayout(fieldInput.detail);
+    control.detailFixed(detailLayout, {
+      layout: fieldInput.detail.layout === "collapse" ? "row" : void 0
+    });
+  } else if (fieldInput?.format === "date-range") {
+    const options = {
+      ...fieldInput.options
+    };
+    if (!options.colspan) options.colspan = 12;
+    control.control("date-range", options).width("full");
+  } else {
+    const options = fieldInput?.options ?? {};
+    if (!options.colspan) options.colspan = 12;
+    const type = fieldInput?.type ?? "text";
+    control.control(type, options).width("full");
+  }
+  if (fieldInput?.customRender) control.setCustomRender(fieldInput?.customRender);
+  if (col.hideLabel) control.hideLabel();
+  return control;
+}, "buildFormControl");
+var buildFormUiSchema = /* @__PURE__ */ __name((cols) => {
+  const layout = LayoutBuilder.grid().addControls(...cols.map(buildFormControl)).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 rule = buildRule(col);
+    return {
+      ...el,
+      options: {
+        ...el.options ?? {},
+        label: col.label
+      },
+      ...rule && {
+        rule
+      }
+    };
+  });
+  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");
+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",
+  scope: `#/properties/${c.id}`,
+  options: {
+    label: c.label ?? c.id
+  }
+} : {
+  type: "Control",
+  scope: `#/properties/${c.id}`,
+  options: {
+    // Spread fieldInput.options first (e.g. colspan), then layer type-derived options on top.
+    ...c.fieldInput?.options ?? {},
+    label: c.label ?? c.id,
+    ...c.type === "boolean" && {
+      format: "boolean"
+    }
+  }
+}, "buildCalculatedElement");
+var calcPosition = /* @__PURE__ */ __name((c) => c.fieldInput?.position ?? c.position, "calcPosition");
+var injectCalculatedColumnsIntoView = /* @__PURE__ */ __name((viewConfig, calculated, mode) => {
+  if (!calculated.length) return viewConfig;
+  const visible = calculated.filter((c) => isVisibleInMode(c, mode));
+  if (!visible.length) return viewConfig;
+  const jsonSchema = {
+    ...viewConfig.json_schema
+  };
+  jsonSchema.properties = {
+    ...jsonSchema.properties
+  };
+  for (const c of visible) {
+    jsonSchema.properties[c.id] = {
+      type: c.type === "boolean" ? "boolean" : "string",
+      title: c.label ?? c.id
+    };
+  }
+  const uiSchema = {
+    ...viewConfig.ui_schema
+  };
+  const existing = [
+    ...uiSchema.elements ?? []
+  ];
+  const tagged = [
+    ...existing.map((el, i) => ({
+      el,
+      pos: i + 0.5
+    })),
+    ...visible.map((c) => ({
+      el: buildCalculatedElement(c, mode),
+      pos: calcPosition(c) ?? Infinity
+    }))
+  ];
+  tagged.sort((a, b) => a.pos - b.pos);
+  uiSchema.elements = tagged.map((t) => t.el);
+  const columns = [
+    ...viewConfig.columns
+  ];
+  for (const c of visible) {
+    const pos = calcPosition(c);
+    const entry = {
+      id: c.id,
+      label: c.label
+    };
+    if (pos !== void 0) {
+      columns.splice(pos, 0, entry);
+    } else {
+      columns.push(entry);
+    }
+  }
+  return {
+    ...viewConfig,
+    json_schema: jsonSchema,
+    ui_schema: uiSchema,
+    columns
+  };
+}, "injectCalculatedColumnsIntoView");
+var injectCalculatedColumns = /* @__PURE__ */ __name((tableView, calculated) => injectCalculatedColumnsIntoView(tableView, calculated, "table"), "injectCalculatedColumns");
+var injectCalculatedColumnsToView = /* @__PURE__ */ __name((viewConfig, calculated) => injectCalculatedColumnsIntoView(viewConfig, calculated, "view"), "injectCalculatedColumnsToView");
+var emptyTableView = /* @__PURE__ */ __name(() => ({
+  json_schema: {
+    type: "object",
+    additionalProperties: true,
+    properties: {}
+  },
+  ui_schema: buildTableUiSchema([]),
+  columns: []
+}), "emptyTableView");
+var buildViews = /* @__PURE__ */ __name((schema, columns) => {
+  const views = {};
+  const table = buildView(schema, columns, (c) => !c.hiddenInTable, buildTableUiSchema);
+  if (table) {
+    table.defaultSort = resolveDefaultSort(table.columns, columns);
+    views.table = table;
+  } else if (columns?.length) {
+    views.table = emptyTableView();
+  }
+  const form = buildView(schema, columns, (c) => !c.hiddenInForm, buildFormUiSchema, true, (c) => c.createable === true || c.updateable === true);
+  if (form) views.form = form;
+  const filter = buildView(schema, columns, (c) => !!c.filterable, buildFormUiSchema, true);
+  if (filter) {
+    patchFilterProperties(filter.json_schema, columns?.filter((c) => !!c.filterable));
+    views.filter = filter;
+  }
+  const view = buildView(schema, columns, (c) => !c.hiddenInView, buildFormUiSchema, true);
+  if (view) views.view = view;
+  return Object.keys(views).length ? views : void 0;
+}, "buildViews");
+var buildViewsFromColumns = /* @__PURE__ */ __name((columns) => {
+  if (!columns?.length) return void 0;
+  const buildJsonSchema = /* @__PURE__ */ __name((cols) => {
+    const properties = {};
+    for (const c of cols) {
+      if (c.column) {
+        if (!properties[c.column]) {
+          properties[c.column] = {
+            type: "object",
+            additionalProperties: true,
+            properties: {}
+          };
+        }
+        const keyPath = (c.displayKey ?? c.id).split(".");
+        let target = properties[c.column].properties;
+        for (let i = 0; i < keyPath.length - 1; i++) {
+          const segment = keyPath[i];
+          if (!target[segment]) {
+            target[segment] = {
+              type: "object",
+              additionalProperties: true,
+              properties: {}
+            };
+          }
+          target = target[segment].properties;
+        }
+        target[keyPath[keyPath.length - 1]] = {
+          type: "string",
+          title: c.label ?? c.id
+        };
+      } else {
+        properties[c.id] = {
+          type: c.columnType ?? "string",
+          title: c.label ?? c.id
+        };
+      }
+    }
+    return {
+      type: "object",
+      additionalProperties: true,
+      properties
+    };
+  }, "buildJsonSchema");
+  const fixNestedScopes = /* @__PURE__ */ __name((uiSchema, cols) => {
+    const colMap = Object.fromEntries(cols.map((c) => [
+      c.id,
+      c
+    ]));
+    const elements = uiSchema.elements;
+    if (!elements) return uiSchema;
+    return {
+      ...uiSchema,
+      elements: elements.map((el) => {
+        const id = el.scope?.replace("#/properties/", "");
+        const col = id ? colMap[id] : void 0;
+        if (!col?.column) return el;
+        const keyPath = (col.displayKey ?? col.id).split(".");
+        const propPath = keyPath.map((k) => `properties/${k}`).join("/");
+        return {
+          ...el,
+          scope: `#/properties/${col.column}/${propPath}`
+        };
+      })
+    };
+  }, "fixNestedScopes");
+  const makeView = /* @__PURE__ */ __name((visible, buildUiSchema) => {
+    if (!visible.length) return void 0;
+    return {
+      json_schema: buildJsonSchema(visible),
+      ui_schema: fixNestedScopes(buildUiSchema(visible), visible),
+      columns: visible.map(toViewColumn)
+    };
+  }, "makeView");
+  const views = {};
+  const tableCols = sortByPosition(columns.filter((c) => !c.hiddenInTable));
+  const table = makeView(tableCols, buildTableUiSchema);
+  if (table) {
+    table.defaultSort = resolveDefaultSort(tableCols, columns);
+    views.table = table;
+  } else {
+    views.table = emptyTableView();
+  }
+  const formCols = sortByPosition(columns.filter((c) => !c.hiddenInForm));
+  const form = makeView(formCols, buildFormUiSchema);
+  if (form) views.form = form;
+  const viewCols = sortByPosition(columns.filter((c) => !c.hiddenInView));
+  const viewView = makeView(viewCols, buildFormUiSchema);
+  if (viewView) views.view = viewView;
+  return Object.keys(views).length ? views : void 0;
+}, "buildViewsFromColumns");
+
+// src/lib/crud/loader/json-adapter.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;
+    }
+  }
+  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;
+  try {
+    return {
+      json: JSON.parse((0, import_node_fs4.readFileSync)(childJsonPath, "utf-8")),
+      dir: (0, import_node_path5.dirname)(childJsonPath)
+    };
+  } catch {
+    return void 0;
+  }
+}, "resolveChildResource");
+var expandExtendColumns = /* @__PURE__ */ __name((columns, dirPath) => {
+  if (!dirPath) return columns;
+  const result = [];
+  for (const col of columns) {
+    if (!col.extend) {
+      result.push(col);
+      continue;
+    }
+    const resolved = resolveChildResource(col.extend, dirPath);
+    if (!resolved) {
+      console.warn(`[extend] Could not resolve "${col.extend}" for column "${col.id}" \u2014 keeping as-is`);
+      result.push(col);
+      continue;
+    }
+    const refColumns = normalizeColumns(resolved.json.columns) ?? [];
+    const parentColumnKey = col.column ?? col.id;
+    for (const refCol of refColumns) {
+      if (refCol.idField) continue;
+      const virtualId = `${col.id}_${refCol.id}`;
+      const displayKey = refCol.displayKey ? `${refCol.id}.${refCol.displayKey}` : refCol.id;
+      const hiddenInTable = col.hiddenInTable === true || refCol.hiddenInTable === true ? true : col.hiddenInTable ?? refCol.hiddenInTable;
+      const hiddenInForm = col.hiddenInForm === true || refCol.hiddenInForm === true ? true : col.hiddenInForm ?? refCol.hiddenInForm;
+      const hiddenInView = col.hiddenInView === true || refCol.hiddenInView === true ? true : col.hiddenInView ?? refCol.hiddenInView;
+      const override = col.columns?.[virtualId] ?? col.columns?.[refCol.id] ?? {};
+      const virtualCol = {
+        id: virtualId,
+        column: parentColumnKey,
+        displayKey,
+        label: refCol.label ?? refCol.id,
+        columnType: "object",
+        ...hiddenInTable !== void 0 && {
+          hiddenInTable
+        },
+        ...hiddenInForm !== void 0 && {
+          hiddenInForm
+        },
+        ...hiddenInView !== void 0 && {
+          hiddenInView
+        },
+        ...refCol.sortable != null && {
+          sortable: refCol.sortable
+        },
+        ...refCol.fieldInput && {
+          fieldInput: refCol.fieldInput
+        },
+        ...override
+      };
+      result.push(virtualCol);
+    }
+  }
+  return result;
+}, "expandExtendColumns");
+var buildValueLabelColumns = /* @__PURE__ */ __name((columns) => (columns ?? []).flatMap((c) => {
+  const opts = c.fieldInput?.options;
+  if (!opts?.emitObject || !Array.isArray(opts.values)) return [];
+  return [
+    {
+      field: c.column ?? c.id,
+      values: opts.values
+    }
+  ];
+}), "buildValueLabelColumns");
+var applyRelationFormatDefault = /* @__PURE__ */ __name((cols) => cols?.map((col) => {
+  const fi = col.fieldInput;
+  if (fi && fi.resource && !fi.format && !fi.type) {
+    return {
+      ...col,
+      fieldInput: {
+        ...fi,
+        format: "relation"
+      }
+    };
+  }
+  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");
+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) => {
+    const childResolved = resolveChildResource(c.fieldInput.resource, parentDir);
+    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 expandedChildColumns = rawChildColumns ? expandExtendColumns(rawChildColumns, childDir) : void 0;
+    const childColumns = applyRelationFormatDefault(expandedChildColumns) ?? expandedChildColumns;
+    injectEnumValues(childColumns, enums);
+    const enrichedChildColumns = enrichNestedRelationColumns(childColumns, childDir, baseUrl);
+    const childLookupKey = childColumns?.find((col) => col.idField)?.id ?? "id";
+    const childCalculatedColumns = childJson?.calculatedColumns ?? [];
+    let childViews = childJson ? buildViewsFromColumns(enrichedChildColumns) : void 0;
+    if (childViews && childCalculatedColumns.length) {
+      childViews = {
+        ...childViews,
+        table: injectCalculatedColumns(childViews.table, childCalculatedColumns)
+      };
+      if (childViews.view) {
+        childViews = {
+          ...childViews,
+          view: injectCalculatedColumnsToView(childViews.view, childCalculatedColumns)
+        };
+      }
+    }
+    const childOps = childJson?.operations ?? {};
+    return {
+      column: c.id,
+      relation: c.id,
+      childRoute,
+      childModel: c.id,
+      foreignKey: `${parentModel}_id`,
+      name: childJson?.name ?? childRoute,
+      title: childJson?.title ?? childJson?.tag ?? childRoute,
+      idField: childLookupKey,
+      idType: childJson?.idType ?? "string",
+      ...childViews && {
+        views: childViews
+      },
+      operations: {
+        findAll: childOps.findAll !== false,
+        findOne: childOps.findOne !== false,
+        create: childOps.create !== false,
+        update: childOps.update !== false,
+        delete: childOps.delete !== false
+      },
+      ...childJson?.actions?.length && {
+        actions: childJson.actions
+      },
+      ...childJson?.modalSize && {
+        modalSize: childJson.modalSize
+      },
+      ...childJson?.include?.length && {
+        include: childJson.include
+      },
+      ...childJson?.calculatedColumns?.length && {
+        calculatedColumns: childJson.calculatedColumns
+      },
+      ...(c.hiddenInForm === false || c.hiddenInView === false) && {
+        includeInFindOne: true
+      },
+      ...buildValueLabelColumns(childColumns).length && {
+        valueLabelColumns: buildValueLabelColumns(childColumns)
+      }
+    };
+  });
+}, "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");
+var fromJson = /* @__PURE__ */ __name((json, schema, hooks, dirPath, baseUrl, actions, tableActions, enums = {}) => {
+  const rawColumns = expandExtendColumns(normalizeColumns(json.columns) ?? [], dirPath);
+  const columns = enrichRelationTypes(applyRelationFormatDefault(rawColumns) ?? rawColumns, schema);
+  injectEnumValues(columns, enums);
+  const subResources = buildSubResources(columns, json.route, json.model, dirPath, enums, baseUrl);
+  const enrichedColumns = enrichResourceRefColumns(enrichActionColumns(columns, json.route, subResources, baseUrl), dirPath, baseUrl) ?? columns;
+  const calculatedColumns = json.calculatedColumns ?? [];
+  const picked = pickByColumns(schema, enrichedColumns);
+  const createSchema = pickByColumns(schema, enrichedColumns, (c) => !c.idField && c.createable !== false);
+  const updateSchema = pickByColumns(schema, enrichedColumns, (c) => !c.idField && c.updateable !== false);
+  let views = buildViews(schema, enrichedColumns);
+  if (views && calculatedColumns.length) {
+    views = {
+      ...views,
+      table: injectCalculatedColumns(views.table, calculatedColumns)
+    };
+    if (views.view) {
+      views = {
+        ...views,
+        view: injectCalculatedColumnsToView(views.view, calculatedColumns)
+      };
+    }
+  }
+  const lookup = buildLookup(enrichedColumns);
+  const enrichedInclude = enrichIncludeWithSort(json.include, enrichedColumns);
+  const definition = {
+    ...opWithSchema(json.operations.findAll, picked) && {
+      findAll: opWithSchema(json.operations.findAll, picked)
+    },
+    ...opWithSchema(json.operations.findOne, picked) && {
+      findOne: opWithSchema(json.operations.findOne, picked)
+    },
+    ...opWithSchema(json.operations.create, createSchema) && {
+      create: opWithSchema(json.operations.create, createSchema)
+    },
+    ...opWithSchema(json.operations.update, updateSchema) && {
+      update: opWithSchema(json.operations.update, updateSchema)
+    },
+    ...upsertOp(json.operations.upsert, createSchema) && {
+      upsert: upsertOp(json.operations.upsert, createSchema)
+    },
+    ...json.operations.delete !== false && {
+      delete: true
+    }
+  };
+  const display = {
+    mode: json.display?.mode === "page" ? "page" : "modal",
+    customComponent: json.display?.customComponent ?? null
+  };
+  return {
+    name: json.name,
+    route: json.route,
+    model: json.model,
+    tag: json.tag,
+    display,
+    ...json.title && {
+      title: json.title
+    },
+    ...json.sidebar && {
+      sidebar: json.sidebar
+    },
+    ...json.idType && {
+      idType: json.idType
+    },
+    ...lookup?.key && lookup.key !== "id" && {
+      idField: lookup.key
+    },
+    ...json.database && {
+      database: json.database
+    },
+    ...hooks && {
+      hooks
+    },
+    definition,
+    ...views && {
+      views
+    },
+    ...lookup && {
+      lookup
+    },
+    ...subResources.length && {
+      subResources
+    },
+    ...calculatedColumns.length && {
+      calculatedColumns
+    },
+    ...actions?.length && {
+      actions
+    },
+    ...tableActions?.length && {
+      tableActions
+    },
+    ...enrichedInclude?.length && {
+      include: enrichedInclude
+    },
+    ...json.modalSize && {
+      modalSize: json.modalSize
+    },
+    ...buildValueLabelColumns(enrichedColumns).length && {
+      valueLabelColumns: buildValueLabelColumns(enrichedColumns)
+    }
+  };
+}, "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);
+  const labelCol = columns.find((c) => c.showInLookup) ?? columns.find((c) => c.searchable);
+  if (!keyCol && !labelCol) return void 0;
+  return {
+    key: keyCol?.id ?? "id",
+    ...labelCol && {
+      label: labelCol.id
+    }
+  };
+}, "buildLookup");
+
+// src/lib/crud/loader/index.ts
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+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;
+    if (!file) continue;
+    const hooks = await importDefault(file);
+    if (hooks) sub.hooks = hooks;
+  }
+}, "loadSubResourceHooks");
+var loadResourceConfigsFromDir = /* @__PURE__ */ __name(async (dirPath, baseUrl, enumsFile) => {
+  const enums = loadEnumRegistry(dirPath, enumsFile);
+  const entries = (0, import_node_fs5.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 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 config = fromJson(json, schema, hooks, basePath, baseUrl, actions, tableActions, enums);
+      await loadSubResourceHooks(config.subResources ?? [], basePath);
+      configs.push(config);
+      continue;
+    }
+    const tsFile = findModule2(basePath, "resource");
+    if (tsFile) {
+      const config = await importDefault(tsFile);
+      if (config) configs.push(hooks ? {
+        ...config,
+        hooks
+      } : config);
+    }
+  }
+  return configs;
+}, "loadResourceConfigsFromDir");
+
+// src/lib/crud/loader/resource-config.loader.ts
+var ResourceConfigLoader2 = class {
+  static {
+    __name(this, "ResourceConfigLoader");
+  }
+};
+
+// src/lib/crud/loader/fs-resource-config.loader.ts
+var FileSystemResourceConfigLoader = class extends ResourceConfigLoader2 {
+  static {
+    __name(this, "FileSystemResourceConfigLoader");
+  }
+  dirPath;
+  baseUrl;
+  enumsFile;
+  constructor(dirPath, baseUrl, enumsFile) {
+    super(), this.dirPath = dirPath, this.baseUrl = baseUrl, this.enumsFile = enumsFile;
+  }
+  async loadAll() {
+    return loadResourceConfigsFromDir(this.dirPath, this.baseUrl, this.enumsFile);
+  }
+  async loadByRoute(route) {
+    const configs = await this.loadAll();
+    return configs.find((c) => c.route === route);
+  }
+};
+
+// src/lib/crouton-api.module.ts
+function _ts_decorate5(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+var CroutonApiModule = class _CroutonApiModule {
+  static {
+    __name(this, "CroutonApiModule");
+  }
+  static forResources(configs, dataSources, loader, config) {
+    const dataSourceRegistry = new DataSourceRegistry(dataSources);
+    const configRegistry = new ResourceConfigRegistry(loader, configs);
+    const controllers = [
+      ...configs.map((c) => createCrudController(c, config.baseUrl)),
+      createAppLayoutController(configs, config.sidebarGroups, config.title, config.autoSave ?? true)
+    ];
+    return {
+      module: _CroutonApiModule,
+      controllers,
+      providers: [
+        {
+          provide: import_core.APP_FILTER,
+          useClass: CroutonValidationExceptionFilter
+        },
+        {
+          provide: DataSourceRegistry,
+          useValue: dataSourceRegistry
+        },
+        {
+          provide: ResourceConfigRegistry,
+          useValue: configRegistry
+        }
+      ]
+    };
+  }
+  static async forResourceDir(dirPath, dataSourcesPath, config) {
+    const loader = new FileSystemResourceConfigLoader(dirPath, config.baseUrl, config.enumsFile);
+    const configs = await loadResourceConfigsFromDir(dirPath, config.baseUrl, config.enumsFile);
+    const dataSources = await loadDataSourcesFromDir(dataSourcesPath);
+    return _CroutonApiModule.forResources(configs, dataSources, loader, config);
+  }
+  static forLoader(loader, configs, dataSources, config) {
+    return _CroutonApiModule.forResources(configs, dataSources, loader, config);
+  }
+};
+CroutonApiModule = _ts_decorate5([
+  (0, import_common13.Module)({
+    controllers: [],
+    providers: [],
+    exports: []
+  })
+], CroutonApiModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CroutonApiModule,
+  DataSourceRegistry,
+  FileSystemResourceConfigLoader,
+  ResourceConfigLoader,
+  ResourceConfigRegistry,
+  isOperationEnabled,
+  loadDataSourcesFromDir,
+  loadResourceConfigsFromDir,
+  resolveDefinition,
+  schemaFor,
+  upsertOnFor
+});
+//# sourceMappingURL=index.cjs.map