@ghentcdh/crouton-core 0.0.1-alpha.36

package/dist/index.cjs

@@ -0,0 +1,1280 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  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: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BooleanCellBuilder: () => BooleanCellBuilder,
+  Builder: () => Builder,
+  BuilderWithElements: () => BuilderWithElements,
+  CONFIG_FILES: () => CONFIG_FILES,
+  CalculatedColumnSchema: () => CalculatedColumnSchema,
+  CategoryBuilder: () => CategoryBuilder,
+  ControlBuilder: () => ControlBuilder,
+  ControlType: () => ControlType,
+  CroutonConfigSchema: () => CroutonConfigSchema,
+  DataSourceSchema: () => DataSourceSchema,
+  DataSourceShape: () => DataSourceShape,
+  DetailConfigSchema: () => DetailConfigSchema,
+  DetailControlSchema: () => DetailControlSchema,
+  FieldInputSchema: () => FieldInputSchema,
+  FieldVariantSchema: () => FieldVariantSchema,
+  GroupBuilder: () => GroupBuilder,
+  JsonActionSchema: () => JsonActionSchema,
+  JsonColumnSchema: () => JsonColumnSchema,
+  JsonIncludeEntrySchema: () => JsonIncludeEntrySchema,
+  JsonLinkActionSchema: () => JsonLinkActionSchema,
+  JsonOperationsSchema: () => JsonOperationsSchema,
+  JsonProcedureActionSchema: () => JsonProcedureActionSchema,
+  LayoutBuilder: () => LayoutBuilder,
+  LayoutTypes: () => LayoutTypes,
+  ModalSize: () => ModalSize,
+  Operator: () => Operator,
+  OperatorLabel: () => OperatorLabel,
+  OperatorNoValue: () => OperatorNoValue,
+  OperatorOptions: () => OperatorOptions,
+  OperatorsByType: () => OperatorsByType,
+  PositiveRequestNumber: () => PositiveRequestNumber,
+  RelationFieldInputOptionsSchema: () => RelationFieldInputOptionsSchema,
+  RelationType: () => RelationType,
+  RequestSchema: () => RequestSchema,
+  RequestSchemaWithOffset: () => RequestSchemaWithOffset,
+  ResourceJsonSchema: () => ResourceJsonSchema,
+  ResourceJsonShape: () => ResourceJsonShape,
+  ResponseRequestSchema: () => ResponseRequestSchema,
+  ResponseSchema: () => ResponseSchema,
+  RulesetSchema: () => RulesetSchema,
+  SidebarGroupSchema: () => SidebarGroupSchema,
+  SidebarSchema: () => SidebarSchema,
+  Size: () => ModalSize,
+  SortDirEnum: () => SortDirEnum,
+  StringOrArray: () => StringOrArray,
+  TableBuilder: () => TableBuilder,
+  TextCellBuilder: () => TextCellBuilder,
+  WhenConditionSchema: () => WhenConditionSchema,
+  buildFilter: () => buildFilter,
+  buildSort: () => buildSort,
+  buildSortKey: () => buildSortKey,
+  createSchema: () => createSchema,
+  dropNullableFromRequired: () => dropNullableFromRequired,
+  enforceRequiredStringMinLength: () => enforceRequiredStringMinLength,
+  extractFilters: () => extractFilters,
+  filterToString: () => filterToString,
+  findColumnDef: () => findColumnDef,
+  findProperty: () => findProperty,
+  fromValueLabel: () => fromValueLabel,
+  labelFromId: () => labelFromId,
+  mergeFieldVariant: () => mergeFieldVariant,
+  normalizeLabel: () => normalizeLabel,
+  resolveFormField: () => resolveFormField,
+  resolveTableField: () => resolveTableField,
+  resolveViewField: () => resolveViewField,
+  stringToFilter: () => stringToFilter,
+  toValueLabel: () => toValueLabel,
+  transformDataSource: () => transformDataSource,
+  uiFromJsonSchema: () => uiFromJsonSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/request.model.ts
+var import_zod2 = require("zod");
+
+// src/lib/zod.types.ts
+var import_zod = require("zod");
+var PositiveRequestNumber = () => import_zod.z.coerce.number().int().positive().nonnegative();
+var StringOrArray = () => import_zod.z.string().or(import_zod.z.array(import_zod.z.string())).transform((val) => {
+  if (Array.isArray(val)) return val;
+  return [val];
+});
+
+// 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
+  };
+});
+
+// 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 OperatorNoValue = /* @__PURE__ */ new Set(["isnull", "isnotnull"]);
+var OperatorsByType = {
+  string: ["contains", "not_contains", "equals", "not_equals", "isnull", "isnotnull"],
+  number: ["equals", "not_equals", "gt", "lt", "isnull", "isnotnull"],
+  date: ["equals", "not_equals", "gt", "lt", "isnull", "isnotnull"],
+  boolean: ["equals", "not_equals", "isnull", "isnotnull"],
+  enum: ["equals", "not_equals", "isnull", "isnotnull"]
+};
+var getFilterValues = (filter) => {
+  const parts = filter.split(":");
+  const key = parts[0] ?? "";
+  const lastPart = parts[parts.length - 1];
+  const hasOp = parts.length >= 3 && Operator.includes(lastPart);
+  const operator = hasOp ? lastPart : "contains";
+  const value = hasOp ? parts.slice(1, -1).join(":") : parts.slice(1).join(":");
+  return { key, value, operator };
+};
+var buildFilterKey = (keys, filterObj) => {
+  if (keys.length === 1) return { key: keys[0], filterObj };
+  const buildKey = keys.pop();
+  return buildFilterKey(keys, { [buildKey]: filterObj });
+};
+var buildSort = (key, sortDir) => buildSortKey(key.split("."), SortDirEnum.safeParse(sortDir).data ?? "asc");
+var buildSortKey = (keys, sortDir) => {
+  if (keys.length === 1) return { [keys[0]]: sortDir };
+  const buildKey = keys.pop();
+  return buildSortKey(keys, { [buildKey]: sortDir });
+};
+var buildFilter = (filters) => {
+  const filter = {};
+  filters?.forEach((f) => {
+    const { key, value, operator } = getFilterValues(f);
+    if (!key) return;
+    const op = operator || "contains";
+    const filterObj = { [operator || "contains"]: value.toLowerCase() };
+    if (op === "contains") filterObj["mode"] = "insensitive";
+    const build = buildFilterKey(key.split("."), filterObj);
+    filter[build.key] = build.filterObj;
+  });
+  return filter;
+};
+var extractFilters = (filters) => {
+  const result = [];
+  filters.forEach((f) => {
+    const { key, value, operator } = getFilterValues(f);
+    if (!key) return;
+    result.push({ label: key, key, value, operator });
+  });
+  return result;
+};
+var filterToString = (filter) => `${filter.key}:${filter.value}:${filter.operator}`;
+var stringToFilter = (s) => getFilterValues(s);
+
+// 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
+});
+
+// src/lib/create-schema.ts
+var import_zod6 = require("zod");
+var ModalSize = /* @__PURE__ */ ((ModalSize2) => {
+  ModalSize2["xs"] = "xs";
+  ModalSize2["sm"] = "sm";
+  ModalSize2["lg"] = "lg";
+  ModalSize2["xl"] = "xl";
+  return ModalSize2;
+})(ModalSize || {});
+var simplifyNullableAnyOf = (property) => {
+  const anyOf = property["anyOf"];
+  if (!Array.isArray(anyOf) || anyOf.length !== 2) return false;
+  const nonNull = anyOf.find((s) => s["type"] !== "null");
+  const hasNull = anyOf.some((s) => s["type"] === "null");
+  if (nonNull && hasNull) {
+    delete property["anyOf"];
+    Object.assign(property, nonNull);
+    return true;
+  }
+  return false;
+};
+var transformToJsonSchema = (schema) => {
+  const jsonSchema = (0, import_zod6.toJSONSchema)(schema, { unrepresentable: "any", target: "draft-07" });
+  jsonSchema.additionalProperties = true;
+  const properties = jsonSchema.properties;
+  if (properties) {
+    const nullableKeys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(properties)) {
+      if (simplifyNullableAnyOf(properties[key])) nullableKeys.add(key);
+    }
+    const required = jsonSchema.required;
+    if (Array.isArray(required)) {
+      jsonSchema.required = required.filter((key) => !nullableKeys.has(key));
+    }
+  }
+  return jsonSchema;
+};
+var createSchema = (props) => {
+  if (!props.schema) throw new Error("no schema provided");
+  const schema = props.schema;
+  const dtoSchema = props.dtoSchema;
+  const formSchema = transformToJsonSchema(dtoSchema);
+  const optionalSchema = transformToJsonSchema(schema.partial());
+  return {
+    dtoSchema,
+    responseSchema: props.responseSchema ?? dtoSchema,
+    schema: {
+      form: { uiSchema: props.uiSchema, schema: formSchema, modalSize: props.modalSize ?? "sm" },
+      table: props.tableSchema ? { uiSchema: props.tableSchema, schema: optionalSchema } : void 0,
+      filter: props.filterSchema ? { uiSchema: props.filterSchema, schema: optionalSchema } : void 0,
+      uri: props.uri,
+      searchUri: props.searchUri ?? `${props.uri}?filter=`
+    }
+  };
+};
+
+// src/lib/schema.utils.ts
+var dropNullableFromRequired = (schema) => {
+  if (!schema?.properties) return schema;
+  const required = schema.required;
+  if (!Array.isArray(required) || required.length === 0) return schema;
+  const filteredRequired = required.filter((key) => {
+    const prop = schema.properties[key];
+    if (!prop || typeof prop !== "object") return true;
+    const anyOf = prop["anyOf"];
+    return !(Array.isArray(anyOf) && anyOf.some((s) => s?.["type"] === "null"));
+  });
+  if (filteredRequired.length === required.length) return schema;
+  return { ...schema, required: filteredRequired };
+};
+var enforceRequiredStringMinLength = (schema) => {
+  if (!schema?.properties) return schema;
+  const patchedProperties = { ...schema.properties };
+  let changed = false;
+  for (const key of Object.keys(patchedProperties)) {
+    const prop = patchedProperties[key];
+    if (!prop || typeof prop !== "object") continue;
+    if (prop.type === "string" && prop.minLength === void 0) {
+      patchedProperties[key] = { ...prop, minLength: 1 };
+      changed = true;
+    } else if (prop.type === "object") {
+      const patched = enforceRequiredStringMinLength(prop);
+      if (patched !== prop) {
+        patchedProperties[key] = patched;
+        changed = true;
+      }
+    }
+  }
+  return changed ? { ...schema, properties: patchedProperties } : schema;
+};
+var findProperty = (column, schema) => {
+  if (!column.scope) return { id: null, property: null };
+  const id = column.scope?.substring("#/properties/".length);
+  const property = schema?.properties?.[id] ?? {};
+  return { id, property };
+};
+
+// src/lib/layout/base.builder.ts
+var Builder = class {
+  constructor(type) {
+    this.type = type;
+  }
+  type;
+};
+var BuilderWithElements = class extends Builder {
+  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());
+  }
+};
+
+// 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 {
+  constructor(scope, type = "Control") {
+    super(type);
+    this.scope = scope;
+  }
+  scope;
+  options = {
+    format: "Control",
+    styles: {}
+  };
+  _detail;
+  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
+      }
+    };
+  }
+};
+
+// src/lib/layout/layout.builder.ts
+var LayoutTypes = {
+  HorizontalLayout: "HorizontalLayout",
+  VerticalLayout: "VerticalLayout",
+  CollapseLayout: "CollapseLayout",
+  GridLayout: "GridLayout"
+};
+var LayoutBuilder = class _LayoutBuilder extends BuilderWithElements {
+  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
+    };
+  }
+};
+
+// src/lib/from-json.builder.ts
+var uiFromJsonSchema = (jsonSchema) => {
+  const properties = jsonSchema.properties ?? {};
+  const layout = LayoutBuilder.grid();
+  for (const key of Object.keys(properties)) {
+    layout.addControl(ControlBuilder.properties(key));
+  }
+  return layout.build();
+};
+
+// src/lib/value-label.ts
+var wrapOne = (value, values) => {
+  const match = values.find((o) => o.value === value);
+  return { value, label: match ? match.label : String(value) };
+};
+var toValueLabel = (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);
+};
+var fromValueLabel = (input) => {
+  if (Array.isArray(input)) return input.map(fromValueLabel);
+  if (input && typeof input === "object" && "value" in input) {
+    return input.value;
+  }
+  return input;
+};
+
+// src/lib/layout/category.builder.ts
+var CategoryBuilder = class _CategoryBuilder extends BuilderWithElements {
+  constructor(label) {
+    super(label);
+    this.label = label;
+  }
+  label;
+  rule = {
+    effect: "SHOW",
+    condition: {}
+  };
+  static label(label) {
+    return new _CategoryBuilder(label);
+  }
+  build() {
+    return {
+      type: "Category",
+      label: this.label,
+      rule: this.rule,
+      elements: this.buildElements()
+    };
+  }
+};
+
+// src/lib/layout/group.builder.ts
+var GroupBuilder = class _GroupBuilder extends BuilderWithElements {
+  constructor(label) {
+    super(label);
+    this.label = label;
+  }
+  label;
+  static label(label) {
+    return new _GroupBuilder(label);
+  }
+  build() {
+    return {
+      type: "Group",
+      label: this.label,
+      elements: this.buildElements()
+    };
+  }
+};
+
+// src/lib/table/table.builder.ts
+var TextCellBuilder = class _TextCellBuilder extends Builder {
+  constructor(scope, type = "TextCell") {
+    super(type);
+    this.scope = scope;
+  }
+  scope;
+  options;
+  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 {
+  constructor(scope) {
+    super(scope, "BooleanCell");
+  }
+  static properties(property) {
+    return new _BooleanCellBuilder(`#/properties/${property}`);
+  }
+};
+var TableBuilder = class _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/table/table.utils.ts
+var findColumnDef = (column, schema) => {
+  const { id, property } = findProperty(column, schema);
+  return { ...column, id, ...property };
+};
+
+// src/lib/data-source/DataSourceSchema.ts
+var import_zod7 = __toESM(require("zod"), 1);
+var DataSourceShape = import_zod7.default.object({
+  /** Datasource name (folder + `name` in data-source.json). */
+  name: import_zod7.default.string(),
+  /** Env var holding the connection URL. */
+  urlEnv: import_zod7.default.string(),
+  /** Import path for this datasource's generated Zod types (for resource `schema.ts`). */
+  generatedTypesImport: import_zod7.default.string().optional(),
+  /** Datasource type tag. Default `postgres`. */
+  type: import_zod7.default.string().default("postgres"),
+  /** Mark this as the default datasource. Default `false`. */
+  default: import_zod7.default.boolean().default(false),
+  /** Prisma schema path, relative to project root. Default `prisma/<name>/schema.prisma`. */
+  prismaSchema: import_zod7.default.string().optional(),
+  /** Prisma config path, relative to project root. Default `prisma/<name>/prisma.config.ts`. */
+  prismaConfig: import_zod7.default.string().optional(),
+  /** zod-prisma-types output dir, relative to project root. Default `generated/<name>/src`. */
+  zodOutput: import_zod7.default.string().optional(),
+  /** Prisma client output dir, relative to project root. Default `generated/<name>/client`. */
+  clientOutput: import_zod7.default.string().optional()
+});
+var transformDataSource = (data) => {
+  const name = data.name ?? "name";
+  return {
+    ...data,
+    generatedTypesImport: data.generatedTypesImport ?? `@your-scope/generated/${name}`,
+    prismaSchema: data.prismaSchema ?? `prisma/${name}/schema.prisma`,
+    prismaConfig: data.prismaConfig ?? `prisma/${name}/prisma.config.ts`,
+    zodOutput: data.zodOutput ?? `generated/${name}/src`,
+    clientOutput: data.clientOutput ?? `generated/${name}/client`
+  };
+};
+var DataSourceSchema = DataSourceShape.transform(transformDataSource);
+
+// src/lib/data-source/Operations.schema.ts
+var import_zod8 = require("zod");
+var BoolOrUpsertSchema = import_zod8.z.union([
+  import_zod8.z.boolean(),
+  import_zod8.z.object({ upsertOn: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())]) })
+]);
+var JsonOperationsSchema = import_zod8.z.object({
+  findAll: import_zod8.z.boolean().default(true),
+  // default: true — only explicit `false` disables it
+  findOne: import_zod8.z.boolean().default(true),
+  // default: true
+  create: import_zod8.z.boolean().default(true),
+  // default: true
+  update: import_zod8.z.boolean().default(true),
+  // default: true
+  patch: import_zod8.z.boolean().default(true),
+  // default: true
+  upsert: BoolOrUpsertSchema.default(false),
+  // default: disabled; `true` throws at load time — must be `{ upsertOn }`
+  delete: import_zod8.z.boolean().default(true)
+  // default: true
+});
+
+// src/lib/resource/ResourceJson.schema.ts
+var import_zod15 = require("zod");
+
+// src/lib/resource/CalculatedColumn.schema.ts
+var import_zod10 = require("zod");
+
+// src/lib/resource/FieldInput.schema.ts
+var import_zod9 = require("zod");
+var RelationType = import_zod9.z.enum([
+  "oneToOne",
+  "manyToOne",
+  "oneToMany",
+  "manyToMany"
+]);
+var DetailControlSchema = import_zod9.z.object({
+  property: import_zod9.z.string(),
+  // required
+  type: import_zod9.z.string().optional(),
+  // default: 'text'
+  options: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional(),
+  hideLabel: import_zod9.z.boolean().optional(),
+  // default: false
+  width: import_zod9.z.string().optional()
+});
+var DetailConfigSchema = import_zod9.z.object({
+  layout: import_zod9.z.enum(["collapse", "row"]),
+  // required
+  titleKey: import_zod9.z.string().optional(),
+  controls: import_zod9.z.array(DetailControlSchema)
+  // required
+});
+var RelationFieldInputOptionsSchema = import_zod9.z.object({
+  colspan: import_zod9.z.number().optional().default(12),
+  /** Field to sort related records by, e.g. `"title"` or `"author.name"`. */
+  sort: import_zod9.z.string().optional(),
+  /** Sort direction. Defaults to `"asc"` when omitted. */
+  sortDir: import_zod9.z.enum(["asc", "desc"]).optional(),
+  // default: 'asc'
+  /** CSS flex direction for the relation control button layout. */
+  direction: import_zod9.z.string().optional(),
+  /** Key used as the display label in the relation control. */
+  displayKey: import_zod9.z.string().optional(),
+  /** Path to the related resource (resolved to a URI at load time). */
+  resource: import_zod9.z.string().optional()
+}).catchall(import_zod9.z.unknown());
+var FieldInputSchema = import_zod9.z.object({
+  type: import_zod9.z.string().optional(),
+  customRender: import_zod9.z.string().optional(),
+  /**
+   * Render format hint for the frontend (e.g. `"relation"` for sub-resource
+   * relations). When `format` is `"relation"`, `resource` must also be set.
+   */
+  format: import_zod9.z.string().optional(),
+  // 'relation' triggers relation handling; requires `resource`
+  /**
+   * Relative path to the child resource definition, e.g. `"./author.resource"`.
+   * Only used when `format` is `"relation"`. Resolved at load time to inject
+   * sub-resource URIs into `options`.
+   */
+  resource: import_zod9.z.string().optional(),
+  // required when format === 'relation'
+  /**
+   * Cardinality of the relation. Used by the frontend to determine the correct
+   * renderer and behaviour (e.g. single-select vs multi-select).
+   * - `manyToOne` / `oneToOne`   — single FK reference (autocomplete / relation control)
+   * - `oneToMany` / `manyToMany` — collection (sub-resource table / multi-select)
+   */
+  relationType: RelationType.optional(),
+  // auto-derived from the Zod model/sibling FK column if omitted
+  /** Override the display order in form views. Lower values come first. */
+  position: import_zod9.z.number().optional(),
+  // default: source order
+  options: import_zod9.z.union([RelationFieldInputOptionsSchema, import_zod9.z.unknown()]).optional(),
+  /** Nested array detail layout (renders via `detailFixed`). */
+  detail: DetailConfigSchema.optional()
+});
+var FieldVariantSchema = FieldInputSchema;
+var stripNull = (obj) => {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) if (v !== null) out[k] = v;
+  return out;
+};
+var mergeFieldVariant = (base, override) => {
+  if (!base) return override;
+  if (!override) return base;
+  const merged = stripNull({ ...base, ...override });
+  if (base.options || override.options) {
+    const mergedOptions = stripNull({
+      ...base.options,
+      ...override.options
+    });
+    merged.options = mergedOptions;
+  }
+  return merged;
+};
+
+// src/lib/schema/label.helper.ts
+var labelFromId = (id) => {
+  const words = id.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1).toLowerCase();
+};
+var normalizeLabel = (obj) => {
+  return { label: labelFromId(obj.id), ...obj };
+};
+
+// src/lib/resource/CalculatedColumn.schema.ts
+var CalculatedColumnSchema = import_zod10.z.object({
+  /** Column identifier used in the response payload and UI schema. */
+  id: import_zod10.z.string(),
+  // required
+  /** SQL alias — must match `id`. */
+  alias: import_zod10.z.string(),
+  // required — must match `id`
+  /** Human-readable label shown in the table header. */
+  label: import_zod10.z.string().optional(),
+  sqlExpression: import_zod10.z.string(),
+  // required
+  /** JSON schema / cast type for the computed value. Defaults to `"number"`. `"string"` skips CAST. */
+  type: import_zod10.z.enum(["number", "boolean", "string"]).optional(),
+  // default: 'number'
+  /**
+   * Insertion position relative to the other visible columns.
+   * Uses the same semantics as `fieldInput.position` on regular columns:
+   * `position: N` places this column before the element currently at index N.
+   * Can also be set via `fieldInput.position` (takes precedence).
+   */
+  position: import_zod10.z.number().optional(),
+  hiddenInTable: import_zod10.z.boolean().optional(),
+  // default: false
+  hiddenInView: import_zod10.z.boolean().optional(),
+  // default: false
+  /**
+   * Field input options for rendering in form / view schemas.
+   * Supports `colspan`, `format`, and any other options passed to the Control renderer.
+   * `position` here takes precedence over the top-level `position`.
+   */
+  fieldInput: FieldInputSchema.optional()
+}).transform(normalizeLabel);
+
+// src/lib/resource/Column.ts
+var import_zod11 = require("zod");
+var WhenConditionSchema = import_zod11.z.object({
+  field: import_zod11.z.string(),
+  // required
+  eq: import_zod11.z.unknown().optional(),
+  neq: import_zod11.z.unknown().optional(),
+  exists: import_zod11.z.boolean().optional(),
+  notExists: import_zod11.z.boolean().optional()
+});
+var JsonColumnSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  // required in array form; implied by the map key in map form
+  column: import_zod11.z.string().optional(),
+  // default: same as `id`
+  label: import_zod11.z.string().optional(),
+  // default: title-cased version of `id`
+  hiddenInTable: import_zod11.z.boolean().default(false),
+  // default: false
+  hiddenInForm: import_zod11.z.boolean().default(false),
+  // default: false
+  hiddenInView: import_zod11.z.boolean().default(false),
+  // default: false
+  sortable: import_zod11.z.boolean().default(false),
+  // default: false
+  defaultSort: import_zod11.z.boolean().default(false),
+  // default: false
+  searchable: import_zod11.z.boolean().default(false),
+  // default: false
+  filterable: import_zod11.z.boolean().default(false),
+  // default: false
+  createable: import_zod11.z.boolean().default(true),
+  // default: true (only `false` excludes it)
+  updateable: import_zod11.z.boolean().default(true),
+  // default: true (only `false` excludes it)
+  hideLabel: import_zod11.z.boolean().default(false),
+  // default: false
+  showWhen: WhenConditionSchema.optional(),
+  hideWhen: WhenConditionSchema.optional(),
+  disabledWhen: WhenConditionSchema.optional(),
+  displayKey: import_zod11.z.string().optional(),
+  // e.g. "author.name" for nested display
+  sortId: import_zod11.z.string().optional(),
+  // overrides the sort
+  /**
+   * Name of a shared enum in the project enum registry (`crouton.enums.json`).
+   * At load time the loader injects that enum's `{ value, label }[]` into
+   * `fieldInput.options.values`, so columns don't duplicate the option list.
+   */
+  enum: import_zod11.z.string().optional(),
+  // name of a shared enum in crouton.enums.json
+  idField: import_zod11.z.boolean().default(false),
+  // default: false — exactly one column should set this
+  showInLookup: import_zod11.z.boolean().default(false),
+  // default: false
+  columnType: import_zod11.z.string().default("string"),
+  // default: 'string'
+  fieldInput: FieldInputSchema.optional(),
+  /**
+   * Optional per-context override for the read-only VIEW ui. Same shape as
+   * `fieldInput`; every key optional. Falls back to `fieldInput` (deep-merged
+   * one level into `options`). Resolved at read time by the transformer.
+   */
+  fieldView: FieldVariantSchema.optional(),
+  /**
+   * Optional per-context override for the TABLE ui. Same shape as `fieldInput`;
+   * every key optional. Falls back to `fieldView`, then `fieldInput`.
+   * Resolved at read time by the transformer.
+   */
+  fieldTable: FieldVariantSchema.optional(),
+  /**
+   * Path to another `resource.json` whose columns are expanded as nested sub-columns
+   * under this column's object key.
+   *
+   * Example: `"extend": "../internalAuthor/resource.json"` on a column `author`
+   * auto-generates virtual sub-columns like `author_name` (column: "author", displayKey: "name").
+   *
+   * Visibility (`hiddenInTable/Form/View`) on this column is inherited by all sub-columns as a
+   * default; the referenced resource's own column visibility further restricts it.
+   */
+  extend: import_zod11.z.string().optional(),
+  // path to another resource.json expanded as virtual sub-columns
+  /**
+   * Per-sub-column overrides when using `extend`.
+   * Key: the virtual column id (`"{extendId}_{refColId}"`) or just the referenced column id.
+   * Value: any `JsonColumn` fields to merge over the generated virtual column.
+   */
+  columns: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown())).optional()
+  // per-sub-column overrides, only used with `extend`
+});
+
+// src/lib/resource/Sidebar.schema.ts
+var import_zod12 = __toESM(require("zod"), 1);
+var SidebarGroupSchema = import_zod12.default.object({
+  /** Human-readable heading shown in the sidebar. Defaults to a title-cased version of the slug. */
+  label: import_zod12.default.string().optional(),
+  /** Controls the order of this group among top-level sidebar items. */
+  position: import_zod12.default.number().optional()
+});
+var SidebarSchema = import_zod12.default.object({
+  hide: import_zod12.default.boolean().default(false),
+  // default: false
+  position: import_zod12.default.number().optional(),
+  // default: sorted alphabetically after positioned entries
+  label: import_zod12.default.string().optional(),
+  // default: resource `title`
+  /**
+   * Slug of the group this resource belongs to.
+   * Must match a key in `sidebarGroups` in `crouton.json`.
+   * Resources with the same `group` are nested under a shared collapsible section.
+   */
+  group: import_zod12.default.string().optional()
+  // must match a key in `sidebarGroups` (crouton.json)
+});
+
+// src/lib/resource/TableAction.schema.ts
+var import_zod13 = require("zod");
+var ActionConditionSchema = import_zod13.z.object({
+  /** Row field to evaluate. */
+  field: import_zod13.z.string(),
+  //
+  /**
+   * Comparison operator. Defaults to `"eq"`.
+   * - `eq` / `neq`         — strict equality
+   * - `gt` / `gte` / `lt` / `lte` — numeric or date comparison
+   * - `exists`             — field is not null / undefined / empty string
+   * - `notExists`          — field is null / undefined / empty string
+   */
+  op: import_zod13.z.enum(["eq", "neq", "gt", "gte", "lt", "lte", "exists", "notExists"]).default("eq"),
+  // default: 'eq'
+  /** Comparison value. Not required for `exists` / `notExists`. */
+  value: import_zod13.z.unknown().optional()
+  // not required for exists/notExists
+});
+var ActionSchema = import_zod13.z.object({
+  type: import_zod13.z.string(),
+  /** Unique identifier for the action. */
+  id: import_zod13.z.string(),
+  // required
+  /** Human-readable button label. */
+  label: import_zod13.z.string(),
+  /** MDI icon name, e.g. `"mdi:open-in-new"`. */
+  icon: import_zod13.z.string().optional(),
+  /** Tooltip text. Falls back to `label` when omitted. */
+  tooltip: import_zod13.z.string().optional(),
+  // default: falls back to `label`
+  condition: ActionConditionSchema.optional()
+});
+var JsonProcedureActionSchema = ActionSchema.extend({
+  type: import_zod13.z.literal("procedure").default("procedure"),
+  // default: 'procedure'
+  /**
+   * Filename (without extension) inside the resource's `actions/` directory
+   * that exports the table-action procedure, e.g. `"syncZotero"`.
+   */
+  procedure: import_zod13.z.string(),
+  // required
+  /** HTTP method for the frontend. Defaults to `"post"`. */
+  method: import_zod13.z.string().optional().default("post"),
+  // default: 'post'
+  /** Static query / body params passed to the endpoint. */
+  data: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional()
+});
+var JsonLinkActionSchema = ActionSchema.extend({
+  /** Optional condition evaluated per row. Button is hidden when the condition is false. */
+  type: import_zod13.z.literal("link").default("link"),
+  // required
+  /** URL to open. May contain `{env.VAR}` placeholders. */
+  href: import_zod13.z.string()
+  // required
+});
+var transformAction = (action) => {
+  const label = action.label;
+  return {
+    tooltip: label,
+    ...action
+  };
+};
+var JsonActionSchema = import_zod13.z.union([JsonProcedureActionSchema, JsonLinkActionSchema]).transform(transformAction);
+
+// src/lib/resource/include.schema.ts
+var import_zod14 = require("zod");
+var JsonIncludeEntrySchema = import_zod14.z.lazy(
+  () => import_zod14.z.union([
+    import_zod14.z.string(),
+    // plain relation name → `{ [name]: true }`
+    import_zod14.z.object({
+      relation: import_zod14.z.string(),
+      // required
+      include: import_zod14.z.array(JsonIncludeEntrySchema).optional(),
+      // nested includes;
+      /** Prisma-format orderBy clause applied to the included records. */
+      orderBy: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).optional()
+    })
+  ])
+);
+
+// src/lib/resource/ResourceJson.schema.ts
+var JsonColumnsMapSchema = import_zod15.z.record(
+  import_zod15.z.string(),
+  JsonColumnSchema.omit({ id: true }).catchall(import_zod15.z.unknown())
+);
+var ColumnsSchema = JsonColumnsMapSchema;
+var JsonDisplaySchema = import_zod15.z.object({
+  mode: import_zod15.z.enum(["page", "modal"]).default("modal"),
+  // default: 'modal'
+  customComponent: import_zod15.z.string().nullable().optional().default(null)
+  // default: null
+});
+var normalizeColumns = (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)
+  }));
+};
+var ResourceJsonShape = import_zod15.z.object({
+  name: import_zod15.z.string(),
+  // required — unique id, used as the frontend form id
+  route: import_zod15.z.string(),
+  // required — URL segment for generated endpoints
+  model: import_zod15.z.string(),
+  // required — Prisma model name
+  tag: import_zod15.z.string(),
+  // required — OpenAPI tag
+  title: import_zod15.z.string().optional(),
+  // no computed default — used as UI display title
+  table: import_zod15.z.string().optional(),
+  // default: same as `model`
+  database: import_zod15.z.string().optional(),
+  // default: project's default data source
+  sidebar: SidebarSchema.default(SidebarSchema.parse({})),
+  // default: shown, alphabetically ordered, ungrouped
+  display: JsonDisplaySchema.default(JsonDisplaySchema.parse({})),
+  // default: { mode: 'modal', customComponent: null }
+  operations: JsonOperationsSchema,
+  // required key — but every sub-field defaults to enabled
+  columns: ColumnsSchema.default(ColumnsSchema.parse({})),
+  //  id-keyed map; omit for a columnless resource
+  calculatedColumns: import_zod15.z.array(CalculatedColumnSchema).default([]),
+  actions: import_zod15.z.array(JsonActionSchema).default([]),
+  /** Global table-level actions (no record id). Shown as toolbar buttons. */
+  tableActions: import_zod15.z.array(JsonActionSchema).default([]),
+  /** Modal width when opening a form for this resource. */
+  modalSize: import_zod15.z.enum(["xs", "sm", "lg", "xl"]).default("sm"),
+  // default: 'sm' for create/edit modal
+  /**
+   * Relations to include when querying this resource.
+   * Each entry is either a plain relation name (`"author"` → `include: { author: true }`)
+   * or an object for nested includes:
+   * `{ "relation": "text_author", "include": ["author"] }` →
+   *   `include: { text_author: { include: { author: true } } }`
+   */
+  include: import_zod15.z.array(JsonIncludeEntrySchema).default([])
+});
+var ResourceJsonSchema = ResourceJsonShape.transform((obj) => {
+  const title = obj.title ?? labelFromId(obj.name);
+  return { title, ...obj, columns: normalizeColumns(obj.columns) };
+});
+
+// src/lib/resource/fieldVariants.ts
+var resolveFormField = (c) => c.fieldInput;
+var resolveViewField = (c) => mergeFieldVariant(c.fieldInput, c.fieldView);
+var resolveTableField = (c) => mergeFieldVariant(resolveViewField(c), c.fieldTable);
+
+// src/lib/config/CroutonConfig.schema.ts
+var import_zod16 = require("zod");
+var RulesetSchema = import_zod16.z.object({
+  hideIdInTable: import_zod16.z.boolean().default(true),
+  hideIdInForm: import_zod16.z.boolean().default(true),
+  hideIdInView: import_zod16.z.boolean().default(true),
+  hideTimestamps: import_zod16.z.boolean().default(true),
+  hideForeignKeys: import_zod16.z.boolean().default(true),
+  includeRelations: import_zod16.z.boolean().default(false),
+  hideRelationsInTable: import_zod16.z.boolean().default(true),
+  showRelationsInForm: import_zod16.z.boolean().default(true),
+  enumValueLabel: import_zod16.z.boolean().default(true),
+  sharedEnums: import_zod16.z.boolean().default(true),
+  defaultOperations: JsonOperationsSchema.default(
+    JsonOperationsSchema.parse({})
+  )
+});
+var CroutonConfigSchema = import_zod16.z.object({
+  /**
+   * Application title served to the frontend via `GET /_app/layout`.
+   * Displayed in the admin sidebar header.
+   */
+  title: import_zod16.z.string(),
+  /** Where resource directories live, relative to the project root. */
+  resourcesDir: import_zod16.z.string(),
+  /** Where datasource folders live (each with a `data-source.json`). */
+  dataSourcesDir: import_zod16.z.string(),
+  /**
+   * Template for a model's Zod export name. `{Model}` → Prisma model name.
+   * Defaults to `{Model}WithRelationsSchema` (the relations-aware schema
+   * emitted by zod-prisma-types when `createRelationValuesTypes` is on).
+   */
+  schemaExportName: import_zod16.z.string().default("{Model}WithRelationsSchema"),
+  /** Path to the shared enum registry, relative to project root. Default `crouton.enums.json`. */
+  enumsFile: import_zod16.z.string().default("crouton.enums.json"),
+  /** Optional overrides of the default visibility ruleset. */
+  rules: RulesetSchema.default(RulesetSchema.parse({})),
+  /**
+   * Sidebar group definitions, keyed by group slug (e.g. `"metadata"`).
+   * Resources reference a group via `sidebar.group` in their `resource.json`.
+   */
+  sidebarGroups: import_zod16.z.record(import_zod16.z.string(), SidebarGroupSchema).default({}),
+  /**
+   * Whether form fields are saved automatically as the user edits them.
+   * @default true
+   */
+  autoSave: import_zod16.z.boolean().default(true)
+});
+
+// src/lib/config/readConfig.ts
+var CONFIG_FILES = ["crouton.json", "crouton.mjs", "crouton.js"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BooleanCellBuilder,
+  Builder,
+  BuilderWithElements,
+  CONFIG_FILES,
+  CalculatedColumnSchema,
+  CategoryBuilder,
+  ControlBuilder,
+  ControlType,
+  CroutonConfigSchema,
+  DataSourceSchema,
+  DataSourceShape,
+  DetailConfigSchema,
+  DetailControlSchema,
+  FieldInputSchema,
+  FieldVariantSchema,
+  GroupBuilder,
+  JsonActionSchema,
+  JsonColumnSchema,
+  JsonIncludeEntrySchema,
+  JsonLinkActionSchema,
+  JsonOperationsSchema,
+  JsonProcedureActionSchema,
+  LayoutBuilder,
+  LayoutTypes,
+  ModalSize,
+  Operator,
+  OperatorLabel,
+  OperatorNoValue,
+  OperatorOptions,
+  OperatorsByType,
+  PositiveRequestNumber,
+  RelationFieldInputOptionsSchema,
+  RelationType,
+  RequestSchema,
+  RequestSchemaWithOffset,
+  ResourceJsonSchema,
+  ResourceJsonShape,
+  ResponseRequestSchema,
+  ResponseSchema,
+  RulesetSchema,
+  SidebarGroupSchema,
+  SidebarSchema,
+  Size,
+  SortDirEnum,
+  StringOrArray,
+  TableBuilder,
+  TextCellBuilder,
+  WhenConditionSchema,
+  buildFilter,
+  buildSort,
+  buildSortKey,
+  createSchema,
+  dropNullableFromRequired,
+  enforceRequiredStringMinLength,
+  extractFilters,
+  filterToString,
+  findColumnDef,
+  findProperty,
+  fromValueLabel,
+  labelFromId,
+  mergeFieldVariant,
+  normalizeLabel,
+  resolveFormField,
+  resolveTableField,
+  resolveViewField,
+  stringToFilter,
+  toValueLabel,
+  transformDataSource,
+  uiFromJsonSchema
+});
+//# sourceMappingURL=index.cjs.map