@protobase/schema 0.0.0-stage → 0.1.1

package/dist/model.d.ts

@@ -0,0 +1,333 @@
+//#region src/model.d.ts
+export type FieldType = 'text' | 'integer' | 'bigint' | 'decimal' | 'boolean' | 'date' | 'timestamp' | 'uuid' | 'enum' | 'json' | 'relation' | 'file' | 'currency' | 'country';
+export type FieldModel = {
+  name: string;
+  column: string;
+  type: FieldType;
+  nullable: boolean;
+  readOnly: boolean;
+  filterable: boolean;
+  sortable: boolean;
+  aliases: string[];
+  enumValues?: string[];
+  relation?: {
+    resource: string;
+    columns: string[];
+  };
+  /** Never sent with the record; revealed one value at a time (`.sensitive()`). */
+  sensitive?: true;
+  /** A value the form prefills, or `db` when the database supplies it (identity, now(), ...). */
+  default?: {
+    value: unknown;
+  } | {
+    db: true;
+  };
+};
+/** `digitsEnd`: only the end of the value's digits, spaces, `+` and dashes ignored (phone numbers). */
+export type SearchMatch = 'digitsEnd';
+export type ResourceModel = {
+  name: string;
+  table: {
+    schema?: string;
+    name: string;
+  };
+  fields: Record<string, FieldModel>;
+  primaryKey: string[];
+  softDelete?: string;
+  tenant?: string;
+  /** Field names that the bare-text `search` filter matches against. */
+  search?: string[];
+  /** How a search field matches when not by containing the word; see `SearchMatch`. */
+  searchMatch?: Record<string, SearchMatch>;
+  /** The field holding the owning user's id; `.own` capability scopes filter on it. */
+  owner?: string;
+};
+export type SortSpec = Array<[field: string, direction: 'asc' | 'desc']>;
+export type KeyValue = string | number;
+export type ListQuery = {
+  filter?: CheckedFilter;
+  sort?: SortSpec;
+  columns?: string[];
+  cursor?: string;
+  direction?: 'after' | 'before';
+  limit: number;
+};
+export type FieldFormat = 'relative' | 'absolute' | 'compact' | 'percent' | 'badge' | 'code';
+export type FieldViewModel = {
+  label?: string;
+  help?: string;
+  format?: FieldFormat;
+  prefix?: string;
+  decimals?: number;
+  /** What an enum value reads as wherever it is shown; a value without one reads as itself in words (`enumLabel`). */
+  valueLabels?: Record<string, string>;
+};
+export type ListModel = {
+  columns: string[];
+  sort?: SortSpec;
+  /** Defaults for the UI's search box. `ResourceModel.search` is authoritative for what `search(...)` matches on the server. */
+  search?: string[];
+};
+export type DatePreset = 'today' | 'yesterday' | '7d' | '30d' | '90d' | 'month' | 'quarter' | 'year';
+export type FilterWidgetModel = {
+  kind: 'range';
+  field: string;
+  histogram: boolean;
+} | {
+  kind: 'facets';
+  field: string;
+  search: boolean;
+} | {
+  kind: 'dateRange';
+  field: string;
+  presets: DatePreset[];
+} | {
+  kind: 'toggle';
+  field: string;
+};
+/**
+ * Records of another resource on the record page: those whose `field` holds this record's key or, with `through`,
+ * those whose `field` holds one of the `key` values of the `through` records that point at this record (a join table).
+ */
+export type RelatedModel = {
+  kind: 'related';
+  title: string;
+  help?: string;
+  resource: string;
+  field: string;
+  through?: {
+    resource: string;
+    field: string;
+    key?: string;
+    filter?: string;
+  };
+  filter?: string;
+  sort?: string;
+  /** Fields of `resource`, through relations too (`unitId.propertyId`). */
+  columns?: string[];
+  pageSize?: number;
+  empty?: string;
+};
+export type LayoutItemModel = {
+  kind: 'section';
+  title: string;
+  fields: string[];
+  help?: string;
+} | {
+  kind: 'sidebar';
+  fields: string[];
+} | RelatedModel;
+export type ChartRange = '7d' | '30d' | '90d' | '1y' | 'all';
+export type ChartGranularity = 'hour' | 'day' | 'week' | 'month';
+export type ChartModel = {
+  field: string;
+  range: ChartRange;
+  granularity: ChartGranularity;
+};
+export type SaveFeedback = 'toast' | 'button';
+/**
+ * What a named action does in the app: set fields of the record (`update`), delete it (`delete`) or open a link
+ * (`link`, with `{field}` replaced by the record's values). Without it the app runs a handler it registered by name.
+ */
+export type ActionRun = {
+  kind: 'update';
+  values: Record<string, unknown>;
+} | {
+  kind: 'delete';
+} | {
+  kind: 'link';
+  href: string;
+};
+export type ActionModel = {
+  name: string;
+  label: string;
+  icon?: string;
+  confirm?: string;
+  bulk: boolean;
+  run?: ActionRun;
+};
+/** The colour of a status dot in the sidebar. */
+export type StatusTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/** A collapsible list of a few records under the resource's sidebar entry, each with a status dot. */
+export type NavRecentModel = {
+  /** The field whose value picks each record's dot. */
+  status: string;
+  /** Dot colour per status value; values not listed are `neutral`. */
+  tones: Record<string, StatusTone>;
+  /** Status values whose dot pulses, for states that are in progress. */
+  pulse?: string[];
+  /** AIP-160 filter choosing the records that qualify, as the list API takes it. */
+  filter?: string;
+  /** AIP-132 order; the list's sort when omitted. */
+  orderBy?: string;
+  /** How many records to show, 1 to 20; 3 when omitted. */
+  limit?: number;
+};
+export type NavModel = {
+  /** Hide the resource from the sidebar, for line or link tables. */
+  hidden?: boolean;
+  group?: string;
+  order?: number;
+  recent?: NavRecentModel;
+};
+/** An entry in the menu under the signed-in user, at the bottom of the sidebar. */
+export type UserMenuItemModel = {
+  kind: 'resource';
+  resource: string;
+  label?: string;
+  icon?: string;
+} | {
+  kind: 'page';
+  page: string;
+  label?: string;
+  icon?: string;
+} | {
+  kind: 'link';
+  label: string;
+  href: string;
+  icon?: string;
+};
+export type UserMenuModel = {
+  items: UserMenuItemModel[];
+};
+/**
+ * The title replaces `title` in search results; `subtitle` is the second line unless the search matched another search
+ * field, which then shows instead. Without a subtitle, the first search field not in the title is the default.
+ */
+export type SearchResultModel = {
+  title?: string[];
+  subtitle?: string;
+};
+export type ViewModel = {
+  resource: string;
+  /** Shown only to users with one of these roles; a view without roles is the default. */
+  roles?: string[];
+  /** Field used as the record's display title in breadcrumbs, relation links and search results. */
+  title?: string;
+  /** A record in the global search: a title of one or more fields joined by spaces, over a subtitle field by default. */
+  searchResult?: SearchResultModel;
+  nav?: NavModel;
+  names?: {
+    singular: string;
+    plural: string;
+  };
+  icon?: string;
+  help?: string;
+  fields: Record<string, FieldViewModel>;
+  list?: ListModel;
+  filters: FilterWidgetModel[];
+  layout: LayoutItemModel[];
+  chart?: ChartModel;
+  saveFeedback?: SaveFeedback;
+  actions: ActionModel[];
+};
+export type Span = {
+  start: number;
+  end: number;
+};
+export type FieldPath = {
+  kind: 'field';
+  path: string[];
+  span: Span;
+};
+export type DurationUnit = 's' | 'm' | 'h' | 'd' | 'w';
+export type DurationLiteral = {
+  kind: 'duration';
+  amount: number;
+  unit: DurationUnit;
+  span: Span;
+};
+export type Literal = {
+  kind: 'string';
+  value: string;
+  span: Span;
+} | {
+  kind: 'number';
+  value: number;
+  raw: string;
+  span: Span;
+} | {
+  kind: 'boolean';
+  value: boolean;
+  span: Span;
+} | DurationLiteral | {
+  kind: 'timestamp';
+  value: string;
+  span: Span;
+};
+export type NowValue = {
+  kind: 'now';
+  offset?: {
+    sign: '+' | '-';
+    duration: DurationLiteral;
+  };
+  span: Span;
+};
+export type FilterValue = Literal | NowValue;
+export type CompareOp = '=' | '!=' | '<' | '<=' | '>' | '>=';
+export type FilterOf<F> = {
+  kind: 'and';
+  args: FilterOf<F>[];
+  span: Span;
+} | {
+  kind: 'or';
+  args: FilterOf<F>[];
+  span: Span;
+} | {
+  kind: 'not';
+  arg: FilterOf<F>;
+  span: Span;
+} | {
+  kind: 'compare';
+  op: CompareOp;
+  field: F;
+  value: FilterValue;
+  span: Span;
+} | {
+  kind: 'has';
+  field: F;
+  value: Literal;
+  span: Span;
+} | {
+  kind: 'present';
+  field: F;
+  span: Span;
+} | {
+  kind: 'in';
+  field: F;
+  values: Literal[];
+  span: Span;
+} | {
+  kind: 'search';
+  text: string;
+  span: Span;
+} | {
+  kind: 'similar';
+  field: F;
+  text: string;
+  span: Span;
+} | {
+  kind: 'regex';
+  field: F;
+  pattern: string;
+  span: Span;
+} | {
+  kind: 'isNull';
+  field: F;
+  span: Span;
+};
+export type FilterExpr = FilterOf<FieldPath>;
+export type CheckedFilter = FilterOf<FieldModel>;
+export type FilterErrorCode = 'unexpected-character' | 'unterminated-string' | 'invalid-escape' | 'invalid-number' | 'invalid-timestamp' | 'unexpected-token' | 'expected-token' | 'unknown-function' | 'invalid-arguments' | 'unsupported' | 'too-deep' | 'unknown-field' | 'not-filterable' | 'not-sortable' | 'unsupported-traversal' | 'invalid-value' | 'operator-not-allowed' | 'wildcard-not-allowed' | 'invalid-unicode' | 'too-long' | 'invalid-traversal' | 'wrong-arity' | 'wrong-argument' | 'not-boolean' | 'expected-field' | 'no-search-fields';
+export type FilterError = {
+  code: FilterErrorCode;
+  message: string;
+  hint: string;
+  span: Span;
+};
+export type OrderByItem = {
+  path: FieldPath;
+  direction: 'asc' | 'desc';
+  span: Span;
+};
+//#endregion

package/dist/naming.js

@@ -0,0 +1,4 @@
+//#region src/naming.ts
+const snakeCase = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
+//#endregion
+export { snakeCase };

package/dist/nav-recent.d.ts

@@ -0,0 +1,8 @@
+import { NavRecentModel, ResourceModel } from "./model.js";
+//#region src/nav-recent.d.ts
+export declare const statusTones: readonly ["neutral", "info", "success", "warning", "danger"];
+/** How many records a sidebar group shows when `limit` is not set. */
+export declare const defaultRecentLimit = 3;
+/** What is wrong with a sidebar group's config for this model; empty when the group can be shown. */
+export declare const navRecentErrors: (recent: NavRecentModel, model: ResourceModel) => string[];
+//#endregion

package/dist/nav-recent.js

@@ -0,0 +1,37 @@
+import { parseFilter } from "./filter/parse.js";
+import { checkFilter } from "./filter/check.js";
+import { checkOrderBy, parseOrderBy } from "./filter/order-by.js";
+//#region src/nav-recent.ts
+const statusTones = [
+	"neutral",
+	"info",
+	"success",
+	"warning",
+	"danger"
+];
+/** How many records a sidebar group shows when `limit` is not set. */
+const defaultRecentLimit = 3;
+const maxLimit = 20;
+const filterErrors = (model, source) => {
+	const parsed = parseFilter(source);
+	if (!parsed.ok) return parsed.errors;
+	if (!parsed.ast) return [];
+	const checked = checkFilter(model, parsed.ast);
+	return checked.ok ? [] : checked.errors;
+};
+const orderByErrors = (model, source) => {
+	const parsed = parseOrderBy(source);
+	if (!parsed.ok) return parsed.errors;
+	const checked = checkOrderBy(model, parsed.items);
+	return checked.ok ? [] : checked.errors;
+};
+/** What is wrong with a sidebar group's config for this model; empty when the group can be shown. */
+const navRecentErrors = (recent, model) => [
+	...Object.hasOwn(model.fields, recent.status) ? [] : [`status field "${recent.status}" does not exist`],
+	...Object.entries(recent.tones).filter(([, tone]) => !statusTones.includes(tone)).map(([value, tone]) => `tone "${tone}" for "${value}" is not one of ${statusTones.join(", ")}`),
+	...recent.limit === void 0 || Number.isInteger(recent.limit) && recent.limit >= 1 && recent.limit <= maxLimit ? [] : [`limit must be a whole number from 1 to ${maxLimit}`],
+	...recent.filter === void 0 ? [] : filterErrors(model, recent.filter).map((error) => `filter: ${error.message}`),
+	...recent.orderBy === void 0 ? [] : orderByErrors(model, recent.orderBy).map((error) => `orderBy: ${error.message}`)
+];
+//#endregion
+export { defaultRecentLimit, navRecentErrors, statusTones };

package/dist/refs.d.ts

@@ -0,0 +1,11 @@
+import { AnyField, Field } from "./field.js";
+//#region src/refs.d.ts
+export type FieldsInput = Record<string, AnyField | null>;
+export type ActiveFields<F> = { [K in keyof F as F[K] extends null ? never : K]: F[K]; };
+export type Ref<N extends string = string, V = unknown> = {
+  readonly name: N;
+  readonly $value?: V;
+};
+export type Refs<F> = { readonly [K in keyof F & string]: F[K] extends Field<infer V> ? Ref<K, V> : never; };
+export type FieldRefs<F> = Refs<ActiveFields<F>>;
+//#endregion

package/dist/refs.js

@@ -0,0 +1,8 @@
+//#region src/refs.ts
+const createRefs = (make, known) => new Proxy({}, { get: (_, name) => {
+	if (typeof name === "symbol") return void 0;
+	if (known && !known.includes(name)) throw new Error(`Unknown field "${name}"`);
+	return make(name);
+} });
+//#endregion
+export { createRefs };

package/dist/relation-field.d.ts

@@ -0,0 +1,6 @@
+import { Field } from "./field.js";
+//#region src/relation-field.d.ts
+export declare class RelationField<V> extends Field<V> {
+  columns(columns: string[]): Field<V>;
+}
+//#endregion

package/dist/relation-field.js

@@ -0,0 +1,12 @@
+import { Field } from "./field.js";
+//#region src/relation-field.ts
+var RelationField = class extends Field {
+	columns(columns) {
+		return this.with({ relation: {
+			resource: this.meta.relation.resource,
+			columns
+		} });
+	}
+};
+//#endregion
+export { RelationField };

package/dist/resource-model.d.ts

@@ -0,0 +1,15 @@
+import { SearchMatch } from "./model.js";
+import { FieldsInput } from "./refs.js";
+//#region src/resource-model.d.ts
+export type ResourceState = {
+  name: string;
+  table?: string;
+  fields?: FieldsInput;
+  primaryKey?: string[];
+  softDelete?: string;
+  tenant?: string;
+  search?: string[];
+  searchMatch?: Record<string, SearchMatch>;
+  owner?: string;
+};
+//#endregion

package/dist/resource-model.js

@@ -0,0 +1,71 @@
+import { snakeCase } from "./naming.js";
+//#region src/resource-model.ts
+const parseTable = (table) => {
+	const parts = table.split(".");
+	if (parts.length === 1) return { name: parts[0] };
+	if (parts.length === 2) return {
+		schema: parts[0],
+		name: parts[1]
+	};
+	throw new Error(`Invalid table "${table}", expected "table" or "schema.table"`);
+};
+const fieldModel = (name, field) => {
+	const { meta } = field;
+	const column = meta.column ?? snakeCase(name);
+	return {
+		name,
+		column,
+		type: meta.type,
+		nullable: meta.nullable,
+		readOnly: meta.readOnly,
+		filterable: meta.filterable,
+		sortable: meta.sortable,
+		aliases: [...meta.aliases],
+		...meta.hasDefault && { default: { value: meta.defaultValue } },
+		...meta.dbDefault && !meta.hasDefault && { default: { db: true } },
+		...meta.sensitive && { sensitive: true },
+		...meta.enumValues && { enumValues: [...meta.enumValues] },
+		...meta.relation && { relation: {
+			resource: meta.relation.resource,
+			columns: meta.relation.columns ?? [column]
+		} }
+	};
+};
+const assembleModel = (state) => {
+	const { name, table, fields, primaryKey } = state;
+	if (!table) throw new Error(`Resource "${name}" has no table`);
+	if (!fields) throw new Error(`Resource "${name}" has no fields`);
+	if (!primaryKey) throw new Error(`Resource "${name}" has no primary key`);
+	return {
+		name,
+		table: parseTable(table),
+		fields: Object.fromEntries(Object.entries(fields).filter((entry) => entry[1] !== null).map(([key, field]) => [key, fieldModel(key, field)])),
+		primaryKey: [...primaryKey],
+		...state.softDelete && { softDelete: state.softDelete },
+		...state.tenant && { tenant: state.tenant },
+		...state.search && { search: [...state.search] },
+		...state.searchMatch && Object.keys(state.searchMatch).length > 0 && { searchMatch: { ...state.searchMatch } },
+		...state.owner && { owner: state.owner }
+	};
+};
+const sensitiveProblems = (model) => Object.values(model.fields).filter((field) => field.sensitive).flatMap((field) => [
+	...field.filterable ? ["filterable"] : [],
+	...field.sortable ? ["sortable"] : [],
+	...field.aliases.length > 0 ? ["aliased"] : [],
+	...model.search?.includes(field.name) ? ["searched"] : [],
+	...[
+		...model.primaryKey,
+		model.tenant,
+		model.owner,
+		model.softDelete
+	].includes(field.name) ? ["a key, tenant, owner or soft delete field"] : []
+].map((problem) => `sensitive field "${field.name}" cannot be ${problem}`));
+const buildResourceModel = (state) => {
+	const model = assembleModel(state);
+	const problems = sensitiveProblems(model);
+	if (problems.length > 0) throw new Error(`Resource "${model.name}": ${problems.join("; ")}`);
+	return model;
+};
+const ignoredColumns = (fields = {}) => Object.entries(fields).filter(([, field]) => field === null).map(([key]) => snakeCase(key));
+//#endregion
+export { buildResourceModel, ignoredColumns };

package/dist/resource-types.d.ts

@@ -0,0 +1,21 @@
+import { AccessAction, AccessFn } from "./access/types.js";
+import { Field } from "./field.js";
+import { ActiveFields, Ref } from "./refs.js";
+//#region src/resource-types.d.ts
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+export type RecordOf<F> = Prettify<{ [K in keyof ActiveFields<F>]: ActiveFields<F>[K] extends Field<infer V> ? V : never; }>;
+export type KeyRefs = Ref | readonly Ref[];
+export type KeyOf<K> = K extends readonly Ref[] ? { -readonly [I in keyof K]: K[I] extends Ref<string, infer V> ? V : never; } : K extends Ref<string, infer V> ? V : never;
+export type Issue<F> = {
+  field: keyof RecordOf<F> & string;
+  message: string;
+};
+/** Resource-level rules: operation, row filter and record-level check in one function. */
+export type Access<F> = { [A in AccessAction]?: AccessFn<RecordOf<F>>; };
+export type InferRecord<R extends {
+  readonly $fields: unknown;
+}> = RecordOf<R['$fields']>;
+export type RecordKey<R extends {
+  readonly $key: unknown;
+}> = KeyOf<R['$key']>;
+//#endregion

package/dist/resource.d.ts

@@ -0,0 +1,47 @@
+import { ResourceModel, SearchMatch } from "./model.js";
+import { FieldAccess } from "./access/types.js";
+import { FieldRefs, FieldsInput, Ref } from "./refs.js";
+import { ResourceState } from "./resource-model.js";
+import { Access, Issue, KeyRefs, RecordOf } from "./resource-types.js";
+import { z } from "zod";
+//#region src/resource.d.ts
+type SearchRef = Ref & {
+  readonly match?: SearchMatch;
+};
+/** A field picked for search; `digitsEnd()` matches only the end of its digits, ignoring spaces, `+` and dashes. */
+type SearchRefs<F> = { readonly [K in keyof FieldRefs<F>]: FieldRefs<F>[K] & {
+  digitsEnd(): SearchRef;
+}; };
+type Validator<F> = (record: RecordOf<F>) => Issue<F>[] | undefined;
+export declare class ResourceBuilder<F extends FieldsInput = {}, K = never> {
+  readonly state: ResourceState;
+  readonly validators: readonly Validator<F>[];
+  readonly accessRules: Access<F>;
+  readonly $fields: F;
+  readonly $key: K;
+  constructor(state: ResourceState, validators?: readonly Validator<F>[], accessRules?: Access<F>);
+  table(table: string): ResourceBuilder<F, K>;
+  fields<const N extends FieldsInput>(fields: N): ResourceBuilder<N, never>;
+  primaryKey<const P extends KeyRefs>(pick: (r: FieldRefs<F>) => P): ResourceBuilder<F, P>;
+  softDelete(pick: (r: FieldRefs<F>) => Ref): ResourceBuilder<F, K>;
+  tenant(pick: (r: FieldRefs<F>) => Ref): ResourceBuilder<F, K>;
+  /**
+   * Fields matched by `search("...")` and bare words in filters. Authoritative over the UI's list search defaults.
+   * `r.phone.digitsEnd()` matches only the end of the field's digits, for phone numbers.
+   */
+  search(pick: (r: SearchRefs<F>) => SearchRef[]): ResourceBuilder<F, K>;
+  /** The field holding the owning user's id, which `.own` capability scopes filter on. */
+  owner(pick: (r: FieldRefs<F>) => Ref): ResourceBuilder<F, K>;
+  validate(validator: Validator<F>): ResourceBuilder<F, K>;
+  access(rules: Access<F>): ResourceBuilder<F, K>;
+  /** Role-based rules per field, for fields that declared `.access(...)`. */
+  fieldAccess(): Record<string, FieldAccess>;
+  toModel(): ResourceModel;
+  recordSchema(): z.ZodType<RecordOf<F>>;
+  ignoredColumns(): string[];
+  private refs;
+  private knownFields;
+  private next;
+}
+export declare const resource: (name: string) => ResourceBuilder<{}, never>;
+//#endregion

package/dist/resource.js

@@ -0,0 +1,97 @@
+import { buildResourceModel, ignoredColumns } from "./resource-model.js";
+import { createRefs } from "./refs.js";
+import { z } from "zod";
+//#region src/resource.ts
+var ResourceBuilder = class ResourceBuilder {
+	state;
+	validators;
+	accessRules;
+	constructor(state, validators = [], accessRules = {}) {
+		this.state = state;
+		this.validators = validators;
+		this.accessRules = accessRules;
+	}
+	table(table) {
+		return this.next({ table });
+	}
+	fields(fields) {
+		return new ResourceBuilder({
+			...this.state,
+			fields
+		});
+	}
+	primaryKey(pick) {
+		const picked = pick(this.refs());
+		const refs = Array.isArray(picked) ? picked : [picked];
+		return new ResourceBuilder({
+			...this.state,
+			primaryKey: refs.map((ref) => ref.name)
+		}, this.validators, this.accessRules);
+	}
+	softDelete(pick) {
+		return this.next({ softDelete: pick(this.refs()).name });
+	}
+	tenant(pick) {
+		return this.next({ tenant: pick(this.refs()).name });
+	}
+	/**
+	* Fields matched by `search("...")` and bare words in filters. Authoritative over the UI's list search defaults.
+	* `r.phone.digitsEnd()` matches only the end of the field's digits, for phone numbers.
+	*/
+	search(pick) {
+		const picked = pick(createRefs((name) => ({
+			name,
+			digitsEnd: () => ({
+				name,
+				match: "digitsEnd"
+			})
+		}), this.knownFields()));
+		const searchMatch = Object.fromEntries(picked.flatMap((ref) => ref.match ? [[ref.name, ref.match]] : []));
+		return this.next({
+			search: picked.map((ref) => ref.name),
+			searchMatch
+		});
+	}
+	/** The field holding the owning user's id, which `.own` capability scopes filter on. */
+	owner(pick) {
+		return this.next({ owner: pick(this.refs()).name });
+	}
+	validate(validator) {
+		return new ResourceBuilder(this.state, [...this.validators, validator], this.accessRules);
+	}
+	access(rules) {
+		return new ResourceBuilder(this.state, this.validators, {
+			...this.accessRules,
+			...rules
+		});
+	}
+	/** Role-based rules per field, for fields that declared `.access(...)`. */
+	fieldAccess() {
+		return Object.fromEntries(Object.entries(this.state.fields ?? {}).flatMap(([key, field]) => field?.meta.access ? [[key, field.meta.access]] : []));
+	}
+	toModel() {
+		return buildResourceModel(this.state);
+	}
+	recordSchema() {
+		const shape = Object.fromEntries(Object.entries(this.state.fields ?? {}).flatMap(([key, field]) => field ? [[key, field.schema]] : []));
+		return z.object(shape);
+	}
+	ignoredColumns() {
+		return ignoredColumns(this.state.fields);
+	}
+	refs() {
+		return createRefs((name) => ({ name }), this.knownFields());
+	}
+	knownFields() {
+		return Object.entries(this.state.fields ?? {}).filter(([, field]) => field !== null).map(([key]) => key);
+	}
+	next(patch) {
+		return new ResourceBuilder({
+			...this.state,
+			...patch
+		}, this.validators, this.accessRules);
+	}
+};
+const resource = (name) => new ResourceBuilder({ name });
+//#endregion
+export { ResourceBuilder, resource };