@ultimat3/entity 2.0.0 → 4.0.0

package/src/columns-data.ts

@@ -0,0 +1,205 @@
+// The column builders an EXISTING schema needs. `columns.ts` holds the opinionated set — one way
+// to store an id, an instant, money — and every one of them is a decision this framework made for
+// a table it was going to create. These are the shapes a table already has: a `jsonb` payload, a
+// `numeric(18,8)` rate, a calendar `date`, an `int8` id past 2^53, a `bytea` blob, a `text[]`.
+//
+// Two rules run through all of them. A value crossing the driver is parsed by the column that
+// declared it, because the two drivers disagree about what they hand back (`int8` is a string from
+// Bun's `sql` and a `bigint` from PGlite — measured); and nothing here is an `any` hole, so `json()`
+// takes a schema and validates through it.
+
+import { describeValue, formatIssues, type StandardSchemaV1, validate } from '@ultimat3/schema';
+import { isPlainDate, type PlainDate, plainDateUtc } from '@ultimat3/time';
+import { column } from './column';
+import { invariantViolated } from './errors';
+import type { AnyColumn, Column, ColumnMeta } from './types';
+
+const reject = (rule: string, detail: string): never => {
+  throw invariantViolated('column', rule, detail);
+};
+
+/** The rejected value as its SHAPE, never its content — `columns.ts` explains why at length. */
+const got = (value: unknown): string => `got ${describeValue(value)}`;
+
+/**
+ * A `jsonb` column whose CONTENTS are validated. The schema is required and that is the point: a
+ * `json()` returning `unknown` is the `any` hole this framework forbids, and a column is the worst
+ * place for one — the value arrives from the DATABASE as often as from a caller, so the row type
+ * would be a claim nothing ever checked.
+ *
+ * The object is bound as an object, never as a string: a JSON string parameter is stored as a JSON
+ * *string* by Postgres (measured — `'{"a":1}'` comes back as the text, not the object), so
+ * stringifying here would change the value's type in the table.
+ */
+export const json = <T>(schema: StandardSchemaV1<unknown, T>): Column<T> =>
+  column<T>('jsonb', (value) => {
+    const result = validate(schema, value);
+    if (result.issues === undefined) return result.value;
+    // The ISSUES, never the value: `formatIssues` renders path + message, and a column rejection
+    // reaches the caller and the log line where a value has no key left to redact.
+    return reject(
+      'json',
+      `does not match the column's schema — ${formatIssues(result.issues).join('; ')}`,
+    );
+  });
+
+const DIGITS = /^-?\d+$/;
+
+/**
+ * `bigint`, whose row type is a decimal STRING. Neither alternative survives contact:
+ * a JS `bigint` is what `JSON.stringify` throws on — the reason `money.minor` is a `number` — and
+ * a `number` silently loses digits past 2^53, which is precisely the range a legacy `int8` key or
+ * a snowflake id lives in. A string holds every value the column can and crosses every wire this
+ * framework generates.
+ *
+ * Both driver spellings arrive here and leave as one: Bun's `sql` returns `int8` as a string and
+ * PGlite returns a `bigint`, and a row that meant two things by driver is the drift this package
+ * exists to refuse.
+ */
+export const bigint = (): Column<string> =>
+  column<string>('bigint', (value) => {
+    if (typeof value === 'bigint') return value.toString();
+    if (typeof value === 'number') {
+      return Number.isSafeInteger(value)
+        ? String(value)
+        : reject(
+            'bigint',
+            `${String(value)} is past ±2^53, where a JS number is no longer exact — pass the digits as a string`,
+          );
+    }
+    return typeof value === 'string' && DIGITS.test(value)
+      ? value
+      : reject('bigint', `expected whole digits, ${got(value)}`);
+  });
+
+export interface DecimalOptions {
+  /** Emits `numeric(precision, scale)`. Both, or neither — a bare `numeric` is unbounded. */
+  readonly precision?: number;
+  readonly scale?: number;
+}
+
+/**
+ * `numeric(p, s)`, whose row type is the exact decimal STRING Postgres returns. Money is the one
+ * decimal this framework has an opinion about (integer minor units plus a currency, always); this
+ * is every other one — a tax rate, an FX rate, a measurement — where the precision is the column's
+ * and no JS number holds it.
+ *
+ * It is deliberately NOT arithmetic-friendly. A framework that handed back a float here would be
+ * the float-money bug with a different name, and one that shipped a decimal type would be shipping
+ * a numeric tower: the honest thing a driver already does is give you the digits.
+ */
+export const decimal = (options: DecimalOptions = {}): Column<string> => {
+  const { precision, scale } = options;
+  if ((precision === undefined) !== (scale === undefined)) {
+    reject('numeric', 'precision and scale are declared together — numeric(18, 8), or neither');
+  }
+  if (precision !== undefined && scale !== undefined) {
+    if (!Number.isInteger(precision) || precision < 1 || precision > 1000) {
+      reject('numeric', `precision must be 1..1000, ${got(precision)}`);
+    }
+    if (!Number.isInteger(scale) || scale < 0 || scale > precision) {
+      reject('numeric', `scale must be 0..precision, ${got(scale)}`);
+    }
+  }
+  const shape = /^-?\d+(\.\d+)?$/;
+  return column<string>(
+    'numeric',
+    (value) => {
+      const text = typeof value === 'number' ? decimalOfNumber(value) : value;
+      if (typeof text !== 'string' || !shape.test(text)) {
+        return reject('numeric', `expected a decimal number, ${got(value)}`);
+      }
+      const digits = text.replace('-', '').split('.');
+      const fraction = digits[1]?.length ?? 0;
+      if (scale !== undefined && fraction > scale) {
+        return reject(
+          'numeric',
+          `${text} has ${fraction} decimal places and the column stores ${scale} — Postgres would round it, silently`,
+        );
+      }
+      if (
+        precision !== undefined &&
+        (digits[0] ?? '').replace(/^0+(?=\d)/, '').length > precision - (scale ?? 0)
+      ) {
+        return reject('numeric', `${text} does not fit numeric(${precision}, ${scale ?? 0})`);
+      }
+      return text;
+    },
+    precision === undefined || scale === undefined ? {} : { precision, numericScale: scale },
+  );
+};
+
+/**
+ * A float is accepted only where it is exactly representable as written — anything else is the
+ * rounding this column exists to refuse, and refusing it at the write is the only place the caller
+ * still knows what they meant.
+ */
+const decimalOfNumber = (value: number): string =>
+  Number.isFinite(value) ? String(value) : 'not-a-number';
+
+/**
+ * A `date`: a calendar date, with no time and therefore no zone. The row type is
+ * `@ultimat3/time`'s `PlainDate`, which is why this is not `timestamp()` with the clock zeroed —
+ * `effective_on` is the date a rate applies, and stored as an instant it is a different date on
+ * either side of midnight for half the planet.
+ *
+ * A driver hands a `date` column back as a `Date` at UTC midnight (measured: Bun's `sql` and
+ * PGlite both), so that is the one conversion here, by its own name. The value written is the
+ * string: binding a `Date` to a `date` parameter fails outright on a server whose client zone has
+ * no name Postgres knows (`time zone "gmt-0500" not recognized`, measured on 17.10).
+ */
+export const date = (): Column<PlainDate> =>
+  column<PlainDate>('date', (value) => {
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime())
+        ? reject('date', `expected a calendar date, ${got(value)}`)
+        : plainDateUtc(value);
+    }
+    return isPlainDate(value)
+      ? value
+      : reject('date', `expected a YYYY-MM-DD calendar date, ${got(value)}`);
+  });
+
+/**
+ * `bytea`. The row type is a plain `Uint8Array` and both drivers are normalised into one: Bun's
+ * `sql` returns a `Buffer`, PGlite a `Uint8Array`, and the two serialise differently
+ * (`{"type":"Buffer","data":[…]}` against `{"0":…}`) — so a row read through one driver and the
+ * same row read through the other would not be the same object on any wire.
+ */
+export const bytes = (): Column<Uint8Array> =>
+  column<Uint8Array>('bytea', (value) => {
+    if (!(value instanceof Uint8Array)) {
+      return reject('bytea', `expected bytes, ${got(value)}`);
+    }
+    // Already the plain form: the overwhelmingly common case, and it costs one prototype read.
+    return Object.getPrototypeOf(value) === Uint8Array.prototype ? value : new Uint8Array(value);
+  });
+
+/**
+ * `<element>[]` — a Postgres array of a SCALAR column. The element is a column, so its own
+ * `$parse` decides every member: `arrayOf(text({ max: 40 }))` refuses a 41-character tag exactly
+ * where a `text()` column would.
+ *
+ * Money and arrays of arrays are refused rather than approximated: money is three physical columns
+ * and cannot be one array element, and a nested array has no unambiguous literal form.
+ */
+export const arrayOf = <T>(element: Column<T>): Column<readonly T[]> => {
+  const kind = element.$meta.kind;
+  if (kind === 'money' || kind === 'array') {
+    reject(
+      'array',
+      `arrayOf(${kind}) has no single column behind it — an array element is one scalar column`,
+    );
+  }
+  return column<readonly T[]>(
+    'array',
+    (value) => {
+      if (!Array.isArray(value)) return reject('array', `expected an array, ${got(value)}`);
+      return value.map((member) => element.$parse(member));
+    },
+    { element: element as AnyColumn },
+  );
+};
+
+/** The element's own kind, for the projections that need the physical type. */
+export const elementMeta = (meta: ColumnMeta): ColumnMeta | undefined => meta.element?.$meta;

package/src/columns.ts

@@ -10,11 +10,20 @@ import {
   isMoneyScale,
   MAX_MONEY_SCALE,
 } from '@ultimat3/schema';
-import { BARE, column, GENERATED_UUID, makeColumn, makeTimestamp } from './column';
+import {
+  assertColumnName,
+  BARE,
+  column,
+  GENERATED_UUID,
+  makeColumn,
+  makeTimestamp,
+} from './column';
 import { invariantViolated } from './errors';
 import type {
   Column,
   ColumnMap,
+  ColumnMeta,
+  MoneyColumnNames,
   MoneyInput,
   MoneyValue,
   TimestampColumn,
@@ -64,16 +73,22 @@ const parseBrandedUuid = <T extends string>(value: unknown): T => parseUuid(valu
  * derivation — row, insert, `findById`, `update`, `delete` — so mixing two entities' ids is a
  * compile error instead of a query that silently matches nothing.
  */
-export const uuid = <T extends string = string>(): UuidColumn<T> => ({
-  ...makeColumn<T, false>({ ...BARE, kind: 'uuid' }, parseBrandedUuid, false),
+export const uuid = <T extends string = string>(): UuidColumn<T> =>
+  uuidWith({ ...BARE, kind: 'uuid' });
+
+const uuidWith = <T extends string>(meta: ColumnMeta): UuidColumn<T> => ({
+  ...makeColumn<T, false>(meta, parseBrandedUuid, false),
   // Narrower than the generic chain: a uuid key is generated when omitted, so it is the one
   // primary key an insert may leave out.
   primaryKey: () =>
     makeColumn<T, true>(
-      { ...BARE, kind: 'uuid', primaryKey: true, default: GENERATED_UUID },
+      { ...meta, primaryKey: true, default: GENERATED_UUID },
       parseBrandedUuid,
       true,
     ),
+  // Overridden for the same reason `timestamp()`'s is: `uuid().column('user_id').primaryKey()`
+  // must still be the KEY form, which is optional on insert, rather than the general one.
+  column: (name) => uuidWith<T>({ ...meta, name: assertColumnName(name) }),
 });
 
 export interface TextOptions {
@@ -294,7 +309,34 @@ const parseMoney = (value: unknown): MoneyValue => {
  * silent 10,000x reinterpretation of a value the type system, `t.money` and `@ultimat3/money` all
  * carry. `null` in the column is "no explicit scale" and decodes to an ABSENT key, never to `0`.
  */
-export const money = (): Column<MoneyValue> => column<MoneyValue>('money', parseMoney);
+export interface MoneyOptions {
+  /**
+   * Where the three columns already live, for a table this framework did not create. Named per
+   * part and merged over `<name>_minor` / `<name>_currency` / `<name>_scale`, so a legacy
+   * `amount_cents` beside a `currency` is two words rather than three.
+   *
+   * `scale: null` says the table has no scale column at all. What that costs is stated where the
+   * option is declared (`MoneyColumnNames`): every amount is then at the currency's own minor
+   * unit. What it does NOT cost is correctness — an absent scale already means exactly that.
+   */
+  readonly columns?: MoneyColumnNames;
+}
+
+export const money = (options: MoneyOptions = {}): Column<MoneyValue> =>
+  column<MoneyValue>(
+    'money',
+    parseMoney,
+    options.columns === undefined ? {} : { parts: checkedParts(options.columns) },
+  );
+
+/** Every part named goes through the same identifier rule a `.column()` does. */
+const checkedParts = (columns: MoneyColumnNames): MoneyColumnNames => ({
+  ...(columns.minor === undefined ? {} : { minor: assertColumnName(columns.minor) }),
+  ...(columns.currency === undefined ? {} : { currency: assertColumnName(columns.currency) }),
+  ...(columns.scale === undefined || columns.scale === null
+    ? { ...(columns.scale === null ? { scale: null } : {}) }
+    : { scale: assertColumnName(columns.scale) }),
+});
 
 /**
  * Money is the one column whose write type is wider than its row type — `MoneyInput` takes a

package/src/count-by.ts

@@ -4,6 +4,7 @@
 // a `countBy` against Postgres means; a rule added to one driver alone is the drift this file
 // exists to prevent.
 
+import { columnFor } from './column';
 import type { EntityCore } from './entity';
 import { EntityError } from './errors';
 import type { AnyColumn, ColumnKind } from './types';
@@ -86,7 +87,7 @@ export const groupColumnOf = <Row>(
   property: string,
   operation: string,
 ): AnyColumn => {
-  const column = entity.$columns[property];
+  const column = columnFor(entity.$columns, property);
   if (column === undefined) {
     throw notGroupable(
       entity,

package/src/cursor.ts

@@ -7,6 +7,7 @@
 // to still exist, and a row deleted between two pages would silently restart pagination.
 
 import { CursorInvalidError, decodeCursor, encodeCursor } from '@ultimat3/core';
+import { columnFor } from './column';
 import type { EntityCore } from './entity';
 import { invariantViolated } from './errors';
 import type { QueryPlan } from './tenancy';
@@ -28,7 +29,7 @@ const partsOf = (path: string): { readonly property: string; readonly part?: str
 };
 
 const columnAt = <Row>(entity: EntityCore<Row>, path: string): AnyColumn => {
-  const column = entity.$columns[partsOf(path).property];
+  const column = columnFor(entity.$columns, partsOf(path).property);
   if (column === undefined) {
     throw invariantViolated(entity.$name, 'orderBy', `no column "${path}"`);
   }
@@ -51,13 +52,33 @@ const kindAt = <Row>(entity: EntityCore<Row>, path: string): ColumnKind => {
       `${path} is money: order by ${path}.minor or ${path}.currency`,
     );
   }
-  const money = kind === 'money' ? MONEY_PARTS[part] : undefined;
+  // `MONEY_PARTS[part]` alone answers a FUNCTION for `orderBy('price.toString')` — not
+  // `undefined` — so the refusal below never fired and `assertSeekable` minted a cursor for it.
+  const money =
+    kind === 'money' && Object.hasOwn(MONEY_PARTS, part) ? MONEY_PARTS[part] : undefined;
   if (money === undefined) {
     throw invariantViolated(entity.$name, 'orderBy', `${path} names no column part`);
   }
   return money;
 };
 
+/**
+ * The kind a PATH holds, or `undefined` when it names none — the non-throwing half of `kindAt`.
+ *
+ * The in-memory driver asks this about a predicate column and a sort key, both of which are caller
+ * data: an unknown name compares as text there exactly as it always did, rather than turning a
+ * filter into a refusal the Postgres driver does not make. It is what lets a comparison be decided
+ * by the column's DECLARED kind — which is what Postgres decides by — instead of by the JS type of
+ * whichever value is in hand.
+ */
+export const kindOf = <Row>(entity: EntityCore<Row>, path: string): ColumnKind | undefined => {
+  const { property, part } = partsOf(path);
+  const kind = columnFor(entity.$columns, property)?.$meta.kind;
+  if (kind === undefined) return undefined;
+  if (part === undefined) return kind === 'money' ? undefined : kind;
+  return kind === 'money' && Object.hasOwn(MONEY_PARTS, part) ? MONEY_PARTS[part] : undefined;
+};
+
 export const valueAt = (row: unknown, path: string): unknown => {
   const { property, part } = partsOf(path);
   const record = typeof row === 'object' && row !== null ? (row as Record<string, unknown>) : {};

package/src/describe.ts

@@ -5,7 +5,7 @@
 // Money is the one place the projection is not one-to-one: one property becomes the two
 // physical columns that back it.
 
-import { referenceBinding, snake } from './column';
+import { columnName, moneyColumns, referenceBinding } from './column';
 import { currencyCheck, scaleCheck } from './columns';
 import type { Invariant } from './invariants';
 import type { ColumnDescription, EntityDescription, ReferenceDescription } from './registry';
@@ -13,6 +13,8 @@ import type { AnyColumn, ColumnMeta, IndexDef } from './types';
 
 export interface DescribeInput<Row> {
   readonly name: string;
+  /** The physical table. The entity's own name unless `entity(name, { table })` said otherwise. */
+  readonly table: string;
   readonly columns: readonly (readonly [string, AnyColumn])[];
   readonly primaryKey: readonly string[];
   readonly invariants: readonly Invariant<Row>[];
@@ -41,35 +43,60 @@ export const describeReferences = (
     return [
       {
         property,
-        column: snake(property),
+        column: columnName(property, meta),
         nullable: !meta.notNull,
         targetEntity: target.table,
         targetProperty: target.property,
         targetColumn: target.name,
+        onDelete: meta.onDelete ?? null,
       },
     ];
   });
 
+/**
+ * The Postgres type a column becomes. `kind` is what the migration generator reads and its table
+ * falls through to the kind itself for anything it does not name (`SQL_TYPES[kind] ?? kind`), so a
+ * precise type belongs HERE, where the precision, the element and the length are still in scope —
+ * the alternative is a second copy of the column vocabulary inside `@ultimat3/db`.
+ */
+export const sqlTypeOf = (meta: ColumnMeta): string => {
+  if (meta.kind === 'numeric') {
+    return meta.precision === undefined || meta.numericScale === undefined
+      ? 'numeric'
+      : `numeric(${meta.precision}, ${meta.numericScale})`;
+  }
+  if (meta.kind === 'array') {
+    const element = meta.element?.$meta;
+    // `arrayOf` refuses an element that is not one scalar column, so this is total in practice;
+    // `text[]` is the answer that keeps a description renderable rather than throwing inside a
+    // projection, which is the one place an error has no caller to instruct.
+    return `${element === undefined ? 'text' : sqlTypeOf(element)}[]`;
+  }
+  return meta.kind;
+};
+
 const describeColumn = <Row>(
   input: DescribeInput<Row>,
   property: string,
   meta: ColumnMeta,
   reference: ReferenceDescription | undefined,
 ): readonly ColumnDescription[] => {
-  const physical = snake(property);
+  const physical = columnName(property, meta);
   if (meta.kind === 'money') {
-    const currency = `${physical}_currency`;
+    const parts = moneyColumns(property, meta);
+    const currency = parts.currency;
     const shared = {
       notNull: meta.notNull,
       primaryKey: false,
       unique: false,
       hasDefault: false,
       references: null,
+      onDelete: null,
     };
     return [
       {
         property: `${property}Minor`,
-        column: `${physical}_minor`,
+        column: parts.minor,
         kind: 'bigint',
         check: null,
         ...shared,
@@ -85,21 +112,29 @@ const describeColumn = <Row>(
       // currency's own minor unit", which is every amount written before the column existed and
       // every ordinary price after it. A NOT NULL here would demand a scale on values that have
       // none, and `0` is not that value — it means whole units.
-      {
-        property: `${property}Scale`,
-        column: `${physical}_scale`,
-        kind: 'integer',
-        check: scaleCheck(`${physical}_scale`),
-        ...shared,
-        notNull: false,
-      },
+      //
+      // Absent entirely when the table has none: an adopted amount column predating scale is two
+      // physical columns, and describing a third would put a column in the DDL and in every
+      // statement that the table does not have.
+      ...(parts.scale === null
+        ? []
+        : [
+            {
+              property: `${property}Scale`,
+              column: parts.scale,
+              kind: 'integer',
+              check: scaleCheck(parts.scale),
+              ...shared,
+              notNull: false,
+            },
+          ]),
     ];
   }
   return [
     {
       property,
       column: physical,
-      kind: meta.kind,
+      kind: sqlTypeOf(meta),
       notNull: meta.notNull,
       primaryKey: meta.primaryKey || input.primaryKey.includes(property),
       unique: meta.unique,
@@ -109,11 +144,18 @@ const describeColumn = <Row>(
       // traversal reads can never disagree about what a `references()` points at.
       references:
         reference === undefined ? null : `${reference.targetEntity}.${reference.targetColumn}`,
+      // Off the resolved reference, never off `meta` again: a rule with no key is not a thing, and
+      // reading the option twice is two places for the pair to disagree.
+      onDelete: reference?.onDelete ?? null,
     },
   ];
 };
 
 export const describeEntity = <Row>(input: DescribeInput<Row>): EntityDescription => {
+  const physicalOf = (property: string): string => {
+    const column = input.columns.find(([key]) => key === property)?.[1];
+    return column === undefined ? property : columnName(property, column.$meta);
+  };
   const references = new Map(
     describeReferences(input.name, input.columns).map((reference) => [
       reference.property,
@@ -122,8 +164,8 @@ export const describeEntity = <Row>(input: DescribeInput<Row>): EntityDescriptio
   );
   return {
     name: input.name,
-    table: input.name,
-    primaryKey: input.primaryKey.map((property) => snake(property)),
+    table: input.table,
+    primaryKey: input.primaryKey.map(physicalOf),
     columns: input.columns.flatMap(([property, column]) =>
       describeColumn(input, property, column.$meta, references.get(property)),
     ),

package/src/entity.ts

@@ -3,9 +3,9 @@
 // (the typed db handle, migrations, cache tags, the admin UI, the manifest) is projected from
 // this one call.
 
-import { systemClock } from '@ultimat3/core';
 import { describeValue, type StandardSchemaV1 } from '@ultimat3/schema';
-import { bindColumn, snake } from './column';
+import { entityNow } from './clock';
+import { assertColumnName, bindColumn, columnName, moneyColumns } from './column';
 import { newId } from './columns';
 import { describeEntity, describeReferences } from './describe';
 import { invariantViolated } from './errors';
@@ -33,6 +33,15 @@ export interface IndexInit<C extends ColumnMap> {
 
 export interface EntityInit<C extends ColumnMap> {
   readonly columns: C;
+  /**
+   * The physical table, when it is not the entity's own name. The half of adoption a column name
+   * cannot cover: `entity('user', { table: 'users', … })` reads and writes the table that is
+   * already there, and every statement, index name and foreign key follows it.
+   *
+   * The entity NAME stays the framework's key — the registry, the cache tag, `x entities describe`
+   * and every relation are keyed by it — so renaming a table never moves a cache tag or a policy.
+   */
+  readonly table?: string;
   /**
    * The tenant column, said out loud. Omitted, it is inferred from `.tenant()` or a column named
    * `orgId`, so silence never means unscoped.
@@ -106,7 +115,7 @@ const defaultValue = (meta: ColumnMeta): unknown => {
   const declared = meta.default;
   if (declared === undefined) return undefined;
   if (declared.kind === 'value') return declared.value;
-  return declared.by === 'uuid-v7' ? newId() : systemClock.now();
+  return declared.by === 'uuid-v7' ? newId() : entityNow();
 };
 
 export const entity = <const C extends ColumnMap>(
@@ -117,6 +126,7 @@ export const entity = <const C extends ColumnMap>(
   const entries: readonly (readonly [string, AnyColumn])[] = Object.entries(init.columns);
   for (const [property, column] of entries) bindColumn(column, name, property);
 
+  const table = init.table === undefined ? name : assertColumnName(init.table);
   const cacheTag = `entity:${name}`;
   const softDelete = Object.hasOwn(init.columns, SOFT_DELETE_COLUMN);
   const tenantColumn = resolveTenantColumn(name, init.columns, init.tenant);
@@ -147,19 +157,22 @@ export const entity = <const C extends ColumnMap>(
           `${property} is money: name ${property}.minor or ${property}.currency`,
         );
       }
-      return snake(property);
+      return columnName(property, column.$meta);
     }
     if (!isMoney || !MONEY_PARTS.has(part)) {
       throw invariantViolated(name, property, `${property} has no part "${part}"`);
     }
-    return `${snake(property)}_${part}`;
+    const parts = moneyColumns(property, column.$meta);
+    return part === 'minor' ? parts.minor : parts.currency;
   };
 
   const columnsExpr = invariantColumns<C>(
     name,
     entries.map(([property]) => property),
   );
-  const partialWhere = softDelete ? `${snake(SOFT_DELETE_COLUMN)} is null` : undefined;
+  // Through the one resolver, so a soft-delete column the table spells differently is still the
+  // column every partial index excludes rows by.
+  const partialWhere = softDelete ? `${resolve([SOFT_DELETE_COLUMN])} is null` : undefined;
   // Called once, here, so an unknown column throws while the entity is being declared.
   const invariants: readonly Invariant<Row>[] = (init.invariants?.(columnsExpr) ?? []).map((def) =>
     bindInvariant<Row>(def, resolve, partialWhere),
@@ -169,9 +182,11 @@ export const entity = <const C extends ColumnMap>(
     ...entries.flatMap(([property, column]) => {
       const meta = column.$meta;
       if (!meta.unique && !meta.index) return [];
-      const physical = [meta.kind === 'money' ? `${snake(property)}_minor` : snake(property)];
+      const physical = [
+        meta.kind === 'money' ? moneyColumns(property, meta).minor : columnName(property, meta),
+      ];
       return [
-        { name: indexName(name, physical, meta.unique), columns: physical, unique: meta.unique },
+        { name: indexName(table, physical, meta.unique), columns: physical, unique: meta.unique },
       ];
     }),
     ...(init.indexes ?? []).map((index) => {
@@ -191,7 +206,7 @@ export const entity = <const C extends ColumnMap>(
         );
       }
       return {
-        name: indexName(name, columns, unique),
+        name: indexName(table, columns, unique),
         columns,
         unique,
         ...(index.order === undefined ? {} : { order: index.order }),
@@ -208,6 +223,7 @@ export const entity = <const C extends ColumnMap>(
   const describe = (): EntityDescription =>
     describeEntity({
       name,
+      table,
       columns: entries,
       primaryKey,
       invariants,
@@ -251,7 +267,7 @@ export const entity = <const C extends ColumnMap>(
 
   const core: EntityCore<Row, C> = {
     $name: name,
-    $table: name,
+    $table: table,
     $columns: init.columns,
     $primaryKey: primaryKey,
     $indexes: indexes,
@@ -289,7 +305,7 @@ export const entity = <const C extends ColumnMap>(
     $references: references,
   };
 
-  registerEntity({ name, tableName: name, describe, references });
+  registerEntity({ name, tableName: table, describe, references });
   // The columns land on the entity itself so `orgs.id` is a column reference; every framework
   // member is `$`-prefixed, which is why a column may be called `name`.
   return Object.assign(core, init.columns);