better-supabase 0.7.1 → 0.9.0

package/dist/executor-DoE-5iM8.d.ts

@@ -0,0 +1,272 @@
+import { f as Result, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { B as TableMeta, O as RelationMeta, d as Codec, g as FunctionMeta } from "./types-YfwpIE-d.js";
+//#region src/ir/types.d.ts
+/**
+ * The query IR. Every repository call becomes one of these operations; the
+ * executor compiles it to PostgREST or SQL. Column names in the IR are
+ * database names; `Selection` carries the app aliases.
+ */
+type ColumnOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "is" | "like" | "ilike" | "match" | "imatch" | "contains" | "containedBy" | "overlaps" | "fts";
+type Quantifier = "some" | "none" | "every";
+type Condition = {
+  readonly kind: "and";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "or";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "not";
+  readonly item: Condition;
+} | {
+  readonly kind: "column";
+  readonly column: string;
+  readonly op: ColumnOp;
+  readonly value: unknown;
+  /** Full-text search configuration for `fts`. */
+  readonly config?: string;
+  /**
+   * The column is `json`/`jsonb`: containment values are JSON documents,
+   * also when they are arrays, never Postgres array literals.
+   */
+  readonly json?: true;
+  /**
+   * Keys into a json column: the condition compares the text at this path
+   * (`column->a->>b`, `column #>> '{a,b}'`), and `is null` holds when the
+   * key is missing or JSON `null`.
+   */
+  readonly path?: readonly string[];
+} | {
+  readonly kind: "relation";
+  readonly name: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly quantifier: Quantifier;
+  readonly where: Condition | undefined;
+};
+interface SelectColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the column as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  /** Decodes the returned value (see `ColumnMeta.codec`). */
+  readonly codec?: Codec;
+}
+interface OrderTerm {
+  readonly column: string;
+  readonly direction: "asc" | "desc";
+  readonly nulls?: "first" | "last";
+  /**
+   * Added by the repository (the primary key order of `findMany`), not asked
+   * for by the caller, so a split read may sort it approximately.
+   */
+  readonly implicit?: true;
+  /**
+   * Sort `aggregate()` groups by this aggregate of `column`; `count` counts
+   * the group's rows and its `column` is `*`.
+   */
+  readonly aggregate?: AggregateFn | "count";
+  /** Sort by `column` of this to-one relation's row (only on the root table). */
+  readonly relation?: {
+    readonly name: string;
+    readonly relation: RelationMeta;
+    readonly target: TableMeta;
+  };
+}
+interface Include {
+  readonly alias: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  /** Drop parent rows without a match (`!inner`). */
+  readonly required: boolean;
+  /**
+   * `_count` include: returns the number of matching related rows instead of
+   * rows, folded into `row._count[count]` when decoded.
+   */
+  readonly count?: string;
+  /**
+   * `_sum`/`_avg`/`_min`/`_max` include: `selection.aggregate` holds the
+   * measures, folded into `row[`_${fn}`][name]` when decoded.
+   */
+  readonly aggregate?: {
+    readonly fn: AggregateFn;
+    readonly name: string;
+  };
+}
+type AggregateFn = "sum" | "avg" | "min" | "max";
+interface Measure {
+  readonly fn: AggregateFn;
+  /** Key in the returned row (`_sum_amount`, or the column alias in an include). */
+  readonly key: string;
+  /** App column name, the key under `_sum` in the decoded row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the result as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  readonly codec?: Codec;
+}
+/**
+ * Aggregates instead of rows. `Selection.columns` become the grouping
+ * columns; without any, the result is exactly one row.
+ */
+interface Aggregation {
+  /** Also return `_count`, the number of rows in each group. */
+  readonly count: boolean;
+  readonly measures: readonly Measure[];
+}
+interface Selection {
+  readonly columns: readonly SelectColumn[];
+  readonly includes: readonly Include[];
+  readonly aggregate?: Aggregation;
+}
+type CountMode = "exact" | "planned" | "estimated";
+interface SelectOp {
+  readonly kind: "select";
+  readonly table: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  readonly offset: number | undefined;
+  readonly count: CountMode | undefined;
+  /** Only count, return no rows. */
+  readonly head: boolean;
+  readonly single: "one" | "maybe" | undefined;
+  /** `limit` includes one row past the page, which `paginate()` reads to set `hasMore`. */
+  readonly lookAhead?: boolean;
+  /** `limit` bounds a check, not a page: `findOnly` reads two rows to detect a second match. */
+  readonly unpaged?: boolean;
+  /**
+   * Read from this set-returning function instead of the table (`db.$search`).
+   * Only executors with `functionSources` honor it.
+   */
+  readonly source?: FunctionSource;
+}
+/** A function returning `setof <table>`, called with named arguments. */
+interface FunctionSource {
+  readonly schema: string;
+  readonly name: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/** The statement a mutation runs. */
+type MutationKind = "insert" | "upsert" | "update" | "delete";
+/** What the caller asked for: `softDelete` is a `delete` that a plugin turned into an update. */
+type MutationIntent = MutationKind | "softDelete";
+interface MutationBase {
+  /**
+   * What the caller asked for, when a plugin rewrote the mutation into
+   * another kind. The plugin that rewrites it sets this; mutation events
+   * report it.
+   */
+  readonly intent?: MutationIntent;
+  /**
+   * How a mutation without `returning` counts the rows it wrote. Defaults to
+   * `exact`; SQL executors always return the statement's own row count.
+   */
+  readonly count?: CountMode;
+}
+interface BoundedMutation extends MutationBase {
+  /**
+   * The most rows the statement may change. More fails with `max_affected`
+   * and writes nothing. Over PostgREST it needs PostgREST 13 or later.
+   */
+  readonly maxAffected?: number;
+}
+interface InsertOp extends MutationBase {
+  readonly kind: "insert";
+  readonly table: TableMeta;
+  /** Rows keyed by database column names. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly returning: Selection | undefined;
+  readonly onConflict: {
+    readonly columns: readonly string[];
+    readonly action: "update" | "ignore";
+  } | undefined;
+  /**
+   * In a multi-row insert, columns some rows leave out become `null`
+   * instead of their column default.
+   */
+  readonly defaultToNull: boolean;
+}
+interface UpdateOp extends BoundedMutation {
+  readonly kind: "update";
+  readonly table: TableMeta;
+  /** Keyed by database column names. */
+  readonly set: Readonly<Record<string, unknown>>;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+interface DeleteOp extends BoundedMutation {
+  readonly kind: "delete";
+  readonly table: TableMeta;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+type Operation = SelectOp | InsertOp | UpdateOp | DeleteOp;
+type MutationOp = InsertOp | UpdateOp | DeleteOp;
+declare const and: (...items: (Condition | undefined)[]) => Condition | undefined;
+declare const or: (...items: Condition[]) => Condition;
+declare const not: (item: Condition) => Condition;
+declare const column: (name: string, op: ColumnOp, value: unknown) => Condition;
+//#endregion
+//#region src/core/executor.d.ts
+interface ExecuteContext {
+  /** Already includes the call's `timeout`, when it has one. */
+  readonly signal?: AbortSignal;
+  readonly errorMappers: readonly ErrorMapper[];
+  /**
+   * The call's `retry` setting. PostgREST passes it to postgrest-js, which
+   * retries idempotent requests on network errors, 503 and 520; executors
+   * without retries ignore it.
+   */
+  readonly retry?: boolean;
+}
+interface ExecuteResult {
+  /** Rows keyed by the aliases in the operation's selection. */
+  readonly rows: readonly Record<string, unknown>[];
+  readonly count: number | null;
+}
+/**
+ * Runs IR operations. PostgREST (`postgrestExecutor`) and SQL
+ * (`better-supabase/postgres`) are built in; any other backend can implement
+ * this interface and prove it with `testExecutor` from `better-supabase/testing`.
+ */
+interface Executor {
+  readonly name: string;
+  /** Honors `SelectOp.source`. `db.$search` fails on executors without it. */
+  readonly functionSources?: boolean;
+  execute(op: Operation, context: ExecuteContext): Promise<Result<ExecuteResult>>;
+  /** Calls a database function. Optional; `db.$rpc` fails without it. */
+  rpc?(name: string, args: Readonly<Record<string, unknown>>, context: RpcContext): Promise<Result<unknown>>;
+  /**
+   * Runs several reads together, for `db.$many`: one transaction on a SQL
+   * connection. Returns one result per operation, in order. Optional;
+   * without it `db.$many` runs the operations in parallel.
+   */
+  batch?(ops: readonly Operation[], context: ExecuteContext): Promise<readonly Result<ExecuteResult>[]>;
+}
+interface RpcContext extends ExecuteContext {
+  readonly schema: string;
+  /** The function is `stable`: send it as a GET, so read replicas can serve it. */
+  readonly get?: boolean;
+  readonly function?: FunctionMeta;
+  /**
+   * The result columns to select, by database name. Set when a column has a
+   * codec, which reads it as text: a JSON number has already lost an `int8`
+   * past 2^53 or a `numeric`'s digits.
+   */
+  readonly select?: readonly RpcColumn[];
+}
+/** One column of an `RpcContext.select` list. */
+interface RpcColumn {
+  readonly column: string;
+  readonly cast?: "text";
+}
+//#endregion
+export { Selection as C, not as D, column as E, or as O, SelectOp as S, and as T, MutationOp as _, AggregateFn as a, Quantifier as b, Condition as c, FunctionSource as d, Include as f, MutationKind as g, MutationIntent as h, RpcContext as i, CountMode as l, Measure as m, ExecuteResult as n, Aggregation as o, InsertOp as p, Executor as r, ColumnOp as s, ExecuteContext as t, DeleteOp as u, Operation as v, UpdateOp as w, SelectColumn as x, OrderTerm as y };

package/dist/expo/index.d.ts

@@ -1,7 +1,7 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
-import { t as BetterSupabase } from "../define-CJJkkr1-.js";
-import { i as ServerContext, n as ContextOptions, o as ServerOptions, t as BetterServer } from "../server-Bh0EVSwU.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-DprrgyXX.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-YfwpIE-d.js";
+import { t as BetterSupabase } from "../define-DxHHbNEb.js";
+import { i as ServerContext, n as ContextOptions, s as ServerOptions, t as BetterServer } from "../server-types-OohhIQb2.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-C7I8kLK_.js";
 import { t as Validated } from "../shared-DDSjEGDR.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { ImmutableRequest, MiddlewareFunction } from "expo-server";

package/dist/expo/index.js

@@ -1,10 +1,10 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { o as toProblem } from "../problem-BreOl8b8.js";
-import { a as unexpectedResponse, c as extendServer, s as createServer, y as refreshFor } from "../adapter-iKgjHVPx.js";
-import { m as serializeCookie } from "../resolve-tJZY3FEa.js";
-import { a as respond, r as guard, t as defaultExpose } from "../respond-BUgsXNgk.js";
-import { t as withBetterSupabase } from "../composite-DXVUibdi.js";
-import { r as handoffOf } from "../shared-CBxosKK3.js";
+import { c as toProblem } from "../problem-pIiL3WbE.js";
+import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-CEjmtazZ.js";
+import { m as serializeCookie } from "../resolve-CAR9oaKW.js";
+import { a as respond, r as guard, t as defaultExpose } from "../respond-DdhZ9Wbn.js";
+import { t as withBetterSupabase } from "../composite-M6zPs1Xm.js";
+import { r as handoffOf } from "../shared-BmMcMoW9.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { StatusError, setResponseHeaders } from "expo-server";
 //#region src/bridges/expo.ts
@@ -76,7 +76,7 @@ function createExpo(betterSupabase, options = {}) {
 		request,
 		loader(fn, loaderOptions) {
 			return async (incoming, params) => {
-				if (!incoming) throw new StatusError(500, "better-supabase: bs.loader() needs a request; static rendering has none (use createStaticLoader)");
+				if (!incoming) throw new StatusError(500, "better-supabase: bs.loader() needs a request, and static rendering has none. Turn on unstable_useServerRendering on Expo SDK 57, or read public data in a loader built with createStaticLoader from \"expo-server\".");
 				const ctx = await request(incoming, loaderOptions);
 				try {
 					return await fn(ctx, params, incoming);

package/dist/expo-sqlite/index.d.ts

@@ -1,6 +1,6 @@
-import { r as Executor } from "../executor-DvsBbNBS.js";
-import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-CaWigTyR.js";
-import { i as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-DI34G86j.js";
+import { r as Executor } from "../executor-DoE-5iM8.js";
+import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-DKrZr3AC.js";
+import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-DDuWYv0Y.js";
 //#region src/expo-sqlite/executor.d.ts
 /** What an expo-sqlite database or exclusive transaction can run. */
 interface ExpoSqliteContextLike {

package/dist/expo-sqlite/index.js

@@ -1,5 +1,5 @@
-import { n as watch, t as sqliteTables } from "../watch-Xuxrvxq-.js";
-import { i as checkSqlite, r as powersyncExecutor } from "../executor-Bq28caBo.js";
+import { n as watch, t as sqliteTables } from "../watch-DT_B3CnJ.js";
+import { i as checkSqlite, t as powersyncExecutor } from "../executor-BXSHYyW2.js";
 //#region src/expo-sqlite/executor.ts
 const DEFAULT_THROTTLE_MS = 30;
 /** A UUID v4 from SQLite's `randomblob`, for runtimes without `crypto.randomUUID`. */

package/dist/extra-CGQ2_q3S.js

@@ -0,0 +1,10 @@
+//#region src/server/extra.ts
+/** `{ ...base, ...extra }` that keeps lazy getters lazy. */
+function withExtra(base, extra) {
+	return Object.defineProperties({}, {
+		...Object.getOwnPropertyDescriptors(base),
+		...Object.getOwnPropertyDescriptors(extra)
+	});
+}
+//#endregion
+export { withExtra as t };

package/dist/field-errors-CWXN_h_E.d.ts

@@ -0,0 +1,113 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { J as TemplateValues } from "./storage-api-Cx-1iWBd.js";
+import { at as QuerySpec } from "./define-DxHHbNEb.js";
+import { _ as TopicMessage, c as RealtimeClient, d as SubscribeOptions, i as PresenceOptions, s as PresenceSubscription } from "./topic-cMS7UtM1.js";
+import { t as ClientPorts } from "./ports-DAdQyjZz.js";
+import { a as ClientAuth } from "./bind-a7sUgvf4.js";
+import { a as LiveSource, r as LiveCountSeed } from "./index-BIi8i6BO.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { QueryClient } from "@tanstack/query-core";
+//#region src/bindings/client.d.ts
+/** The parts of `createClient()` the bindings need. */
+interface ClientLike {
+  readonly betterSupabase: LiveSource;
+  readonly supabase: SupabaseClient;
+  readonly auth: ClientAuth;
+  readonly db: object;
+  readonly queries: object;
+  /** The platform services block controllers use; see `ClientPorts`. */
+  readonly ports?: ClientPorts;
+}
+/** What a `bs.action()` Server Action or server function resolves to. */
+type ActionResultOf<T> = {
+  readonly ok: true;
+  readonly data: T;
+  readonly error: null;
+} | {
+  readonly ok: false;
+  readonly data: null;
+  readonly error: DbError;
+};
+/**
+ * The input `useAction` passes: a `bs.action()` with an `input` schema also
+ * accepts `FormData`, which belongs to `useActionForm`.
+ */
+type ActionInputOf<I> = [Exclude<I, FormData>] extends [never] ? I : Exclude<I, FormData>;
+interface UseActionOptions<I, T> {
+  readonly onSuccess?: (data: T, input: I) => void;
+  readonly onError?: (error: DbError, input: I) => void;
+}
+interface BroadcastOptions extends Omit<SubscribeOptions, "onStatus"> {
+  /**
+   * A supabase-js client to subscribe with, for apps without the provider.
+   * It resubscribes when the client's user changes. Defaults to the
+   * provider's client.
+   */
+  readonly client?: SupabaseClient;
+  /** The query client `invalidate` refetches with. Defaults to the provider's. */
+  readonly queryClient?: QueryClient;
+  /**
+   * Refetch after each message: table keys (every query that read one of
+   * them), or a function returning query keys. Needs a `queryClient`, here
+   * or on the provider.
+   */
+  readonly invalidate?: readonly string[] | ((message: TopicMessage) => readonly (readonly unknown[])[]);
+}
+interface LiveQueryHookOptions {
+  /**
+   * Tenant for tenant-scoped tables. Defaults to the `config.claims.tenant`
+   * claim (`tenant_id`, top-level or in `app_metadata`).
+   */
+  readonly tenant?: string;
+  /** Defaults to 100 ms. */
+  readonly debounceMs?: number;
+}
+interface LiveCountHookOptions extends LiveQueryHookOptions {
+  /** The count to show before the first fetch, e.g. from the server. */
+  readonly initial?: number;
+}
+interface PresenceHookOptions<I> {
+  /**
+   * The state this client shares while joined. It is tracked after the
+   * join and tracked again when its JSON changes; `null` stays untracked.
+   */
+  readonly state?: I | null;
+  /** A supabase-js client for apps without the provider. */
+  readonly client?: SupabaseClient;
+}
+/** The parts of a `defineTopic(..., { presence })` topic the bindings use. */
+interface PresenceTopic<P extends string, I, O> {
+  topic(values: TemplateValues<P>): string;
+  match(topic: string): TemplateValues<P> | null;
+  subscribe(client: RealtimeClient, values: TemplateValues<P>, handlers: Readonly<Record<string, never>>, options?: SubscribeOptions & PresenceOptions<O>): PresenceSubscription<I, O>;
+}
+/** Who a subscription runs as. */
+/** The claims type of a client's `betterSupabase.claims(schema)`, `unknown` without one. */
+type ClaimsOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly claimsSchema: StandardSchemaV1<unknown, infer C> | undefined;
+} ? C : unknown;
+/** The profile type of a client's `betterSupabase.userMetadata(schema)`, `unknown` without one. */
+type ProfileOf<B extends ClientLike> = B["betterSupabase"] extends {
+  readonly userMetadataSchema: StandardSchemaV1<unknown, infer P> | undefined;
+} ? P : unknown;
+/** A count spec or a `bs.liveCount()` seed. */
+type LiveCountSource = QuerySpec<string, "count", number> | LiveCountSeed | null | undefined;
+interface ActionState<I, T> {
+  /** True while a run is in flight. */
+  readonly pending: boolean;
+  /** The inputs of the runs in flight, e.g. to dim one table row. */
+  readonly pendingInputs: readonly I[];
+  /** The input of the latest run in flight. */
+  readonly pendingInput: I | undefined;
+  /** The data of the last successful run. */
+  readonly data: T | undefined;
+  /** The error of the last run, until the next one starts. */
+  readonly error: DbError | undefined;
+}
+//#endregion
+//#region src/bindings/field-errors.d.ts
+/** The first message per top-level field of a `validation` error. */
+declare function fieldErrorsOf(error: DbError | undefined): Readonly<Partial<Record<string, string>>>;
+//#endregion
+export { BroadcastOptions as a, LiveCountHookOptions as c, PresenceHookOptions as d, PresenceTopic as f, ActionState as i, LiveCountSource as l, UseActionOptions as m, ActionInputOf as n, ClaimsOf as o, ProfileOf as p, ActionResultOf as r, ClientLike as s, fieldErrorsOf as t, LiveQueryHookOptions as u };

package/dist/field-errors-DZVRWRkf.js

@@ -0,0 +1,13 @@
+//#region src/bindings/field-errors.ts
+/** The first message per top-level field of a `validation` error. */
+function fieldErrorsOf(error) {
+	if (error?.kind !== "validation") return {};
+	const fields = {};
+	for (const issue of error.issues) {
+		const key = issue.path?.[0];
+		if (typeof key === "string" && fields[key] === void 0) fields[key] = issue.message;
+	}
+	return fields;
+}
+//#endregion
+export { fieldErrorsOf as t };

package/dist/field-formats-Cif5gr7c.js

@@ -0,0 +1,102 @@
+//#region src/core/contracts/field-formats.ts
+const FIELD_FORMAT_NAMES = [
+	"email",
+	"url",
+	"phone",
+	"long_text",
+	"color",
+	"rating",
+	"percent",
+	"currency"
+];
+/** The stars a `rating` takes, for a column and for a custom field. */
+const RATING_BOUNDS = [1, 5];
+const EMAIL = String.raw`^[^@\s]+@[^@\s]+\.[^@\s]+$`;
+const URL = String.raw`^https?://\S+$`;
+/**
+* Money is a `currency` `bigint` of minor units next to a `text` column of
+* 3 characters for the code (ADR 0037).
+*/
+const FIELD_FORMATS = {
+	email: {
+		types: ["text"],
+		pattern: EMAIL,
+		input: "email",
+		formType: "email"
+	},
+	url: {
+		types: ["text"],
+		pattern: URL,
+		input: "url",
+		formType: "url"
+	},
+	phone: {
+		types: ["text"],
+		input: "tel",
+		formType: "text"
+	},
+	long_text: {
+		types: ["text"],
+		input: "textarea",
+		formType: "textarea"
+	},
+	color: {
+		types: ["text"],
+		input: "color",
+		formType: "text"
+	},
+	rating: {
+		types: ["integer", "bigint"],
+		bounds: RATING_BOUNDS,
+		input: "number",
+		formType: "integer"
+	},
+	percent: {
+		types: ["integer", "numeric"],
+		bounds: [0, 100],
+		input: "number",
+		formType: "number"
+	},
+	currency: {
+		types: ["bigint"],
+		input: "number",
+		formType: "integer"
+	}
+};
+/**
+* The types of a custom field definition. A value is stored as text either
+* way; the type tells the form and the UI what it holds. `user` holds a user
+* id, `currency` an integer of minor units, and `multi_option` a JSON array
+* of option values.
+*/
+const CUSTOM_FIELD_TYPES = [
+	"text",
+	"number",
+	"date",
+	"bool",
+	"option",
+	"json",
+	"email",
+	"url",
+	"multi_option",
+	"user",
+	"rating",
+	"currency"
+];
+/** The forms block field type that answers each custom field type. */
+const CUSTOM_FIELD_FORM_TYPES = {
+	text: "text",
+	number: "number",
+	date: "date",
+	bool: "bool",
+	option: "option",
+	json: "json",
+	email: FIELD_FORMATS.email.formType,
+	url: FIELD_FORMATS.url.formType,
+	multi_option: "multi",
+	user: "text",
+	rating: FIELD_FORMATS.rating.formType,
+	currency: FIELD_FORMATS.currency.formType
+};
+//#endregion
+export { RATING_BOUNDS as a, FIELD_FORMAT_NAMES as i, CUSTOM_FIELD_TYPES as n, FIELD_FORMATS as r, CUSTOM_FIELD_FORM_TYPES as t };

package/dist/field-formats-DCvOQlOy.d.ts

@@ -0,0 +1,39 @@
+import { s as FormFieldType } from "./form-definition-sagoefQr.js";
+//#region src/core/contracts/field-formats.d.ts
+/**
+ * The one field vocabulary: the formats an app table column takes and the
+ * types a custom field takes. App tables render each format's check from
+ * here, `scaffold screens` picks the input, and the forms block answers a
+ * custom field with the form field type it maps to.
+ */
+/** The Postgres column types a format fits. */
+type FieldFormatColumnType = "text" | "integer" | "bigint" | "numeric";
+/** The HTML input a format edits with. */
+type FieldFormatInput = "email" | "url" | "tel" | "textarea" | "color" | "number";
+interface FieldFormat {
+  readonly types: readonly FieldFormatColumnType[];
+  /** A POSIX regular expression the value matches, ignoring case. */
+  readonly pattern?: string;
+  /** The bounds when the column sets no `min` or `max`. */
+  readonly bounds?: readonly [min: number, max: number];
+  readonly input: FieldFormatInput;
+  /** The forms block field type that collects the value. */
+  readonly formType: FormFieldType;
+}
+declare const FIELD_FORMAT_NAMES: readonly ["email", "url", "phone", "long_text", "color", "rating", "percent", "currency"];
+type FieldFormatName = (typeof FIELD_FORMAT_NAMES)[number];
+/**
+ * Money is a `currency` `bigint` of minor units next to a `text` column of
+ * 3 characters for the code (ADR 0037).
+ */
+declare const FIELD_FORMATS: Readonly<Record<FieldFormatName, FieldFormat>>;
+/**
+ * The types of a custom field definition. A value is stored as text either
+ * way; the type tells the form and the UI what it holds. `user` holds a user
+ * id, `currency` an integer of minor units, and `multi_option` a JSON array
+ * of option values.
+ */
+declare const CUSTOM_FIELD_TYPES: readonly ["text", "number", "date", "bool", "option", "json", "email", "url", "multi_option", "user", "rating", "currency"];
+type CustomFieldType = (typeof CUSTOM_FIELD_TYPES)[number];
+//#endregion
+export { FieldFormat as a, FIELD_FORMAT_NAMES as i, CustomFieldType as n, FieldFormatInput as o, FIELD_FORMATS as r, FieldFormatName as s, CUSTOM_FIELD_TYPES as t };