@drhomet/mithaq 0.0.0-stage → 0.2.0

package/dist/zod/kinds.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { isJson } from '../base/kinds.js';
+import { isDecimal } from '../base/decimal.js';
+import { jsonSchemaCheck } from '../base/json-schema.js';
+// A missing key, or a `null` on a required field, is the `required` rule refusing;
+// anything else is the kind refusing the value. A field with no kayan keeps zod's text.
+export const errorOf = (field, element = false) => field?.kayan
+    ? (issue) => issue.input === undefined || (issue.input === null && !element && field.rules?.required === true)
+        ? `${field.kayan}.${field.name}.required`
+        : `${field.kayan}.${field.name}.invalid`
+    : undefined;
+const idShapes = {
+    // A number id is an int4 `serial`, so a fraction or a value past its range is a 400, not a Postgres 500.
+    number: (error) => z.int32({ error }),
+    text: (error) => z.string({ error }),
+    // `guid`, not `uuid`: `z.uuid()` also demands an RFC version and variant, which Postgres does not.
+    // Lower-cased, the spelling Postgres answers, so a step comparing ids as text sees one id.
+    uuid: (error) => z.guid({ error }).toLowerCase(),
+};
+/** The kinds this target shapes an id of, the same three the store's columns are. */
+export const idKinds = Object.keys(idShapes);
+const idShape = (kind, error) => idShapes[kind](error);
+// Narrowed to the field's `options` on the server, not only in the browser.
+const textShape = (field, element = false) => {
+    const values = field?.options?.map((option) => option.value);
+    return values?.length ? z.enum(values, { error: errorOf(field, element) }) : z.string({ error: errorOf(field, element) });
+};
+/** One shape per kind, the same record shape as the adapter's kinds. */
+export const kinds = {
+    text: textShape,
+    email: (field) => z.email({ error: errorOf(field) }),
+    // The id is the `serial` column `idShapes` says it is; any other number is a
+    // `numeric` column, which takes every finite number.
+    number: (field) => (field?.name === 'id' ? idShape('number', errorOf(field)) : z.number({ error: errorOf(field) })),
+    // A Postgres `integer`, the same int4 a number id is.
+    integer: (field) => z.int32({ error: errorOf(field) }),
+    // A JS number is refused: it may already have lost a digit. `abort`, so no
+    // rule after it reads text that is no decimal.
+    decimal: (field) => z.string({ error: errorOf(field) }).refine(isDecimal, { error: errorOf(field), abort: true }),
+    checkbox: (field) => z.boolean({ error: errorOf(field) }),
+    datetime: (field) => z.date({ error: errorOf(field) }),
+    // A string, so a `Date` is refused rather than truncated to whichever day its zone makes of it.
+    date: (field) => z.iso.date({ error: errorOf(field) }),
+    // The same error on each element, so a bad element reads as the field's own sentence.
+    textArray: (field) => z.array(textShape(field, true), { error: errorOf(field) }),
+    uuid: (field) => idShape('uuid', errorOf(field)),
+    relationship: (field) => field.hasMany
+        ? z.array(idShape(field.target.fields.id.kind, errorOf(field, true)), { error: errorOf(field) })
+        : idShape(field.target.fields.id.kind, errorOf(field)),
+    // Only what JSON can say, so a value reads back as it was written; `z.json()` lets a cycle through.
+    // A `jsonSchema` only judges: what is stored is the value as sent.
+    json: (field) => {
+        const shape = z.custom((value) => isJson(value) && !(field?.maxBytes && new TextEncoder().encode(JSON.stringify(value)).length > field.maxBytes), { error: errorOf(field) });
+        return field?.jsonSchema ? shape.refine(jsonSchemaCheck(field), { error: errorOf(field) }) : shape;
+    },
+    // Left loose: the child's row shape may not be derived yet, and the child's own read already parsed the rows.
+    join: (field) => z.array(z.record(z.string(), z.unknown()), { error: errorOf(field) }),
+};

package/dist/zod/rules.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import type { ResolvedField } from '../mithaq/types.ts';
+export declare const rules: {
+    /** The database enforces it, and only the database can. */
+    unique: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** Nothing about reading rows faster changes what a write must look like. */
+    index: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** A rule about deleting the other row, and a write is not a delete. */
+    onDelete: ({ shape }: {
+        shape: z.ZodType;
+        value: import("../index.ts").OnDelete;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    providedBy: ({ shape }: {
+        shape: z.ZodType;
+        value: Readonly<{
+            create?: import("../base/rules.ts").Provider;
+            update?: import("../base/rules.ts").Provider;
+        }>;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    minLength: ({ shape, value: length, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodString;
+    maxLength: ({ shape, value: length, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodString;
+    pattern: ({ shape, value: expression, field }: {
+        shape: z.ZodType;
+        value: RegExp;
+        field: ResolvedField;
+    }) => z.ZodString;
+    precision: ({ shape, value: precision, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    scale: ({ shape, value: scale, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    min: ({ shape, value, field }: {
+        shape: z.ZodType;
+        value: string | number;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    max: ({ shape, value, field }: {
+        shape: z.ZodType;
+        value: string | number;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    minRows: ({ shape, value: rows, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    maxRows: ({ shape, value: rows, field }: {
+        shape: z.ZodType;
+        value: number;
+        field: ResolvedField;
+    }) => z.ZodArray<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    trim: ({ shape, value: on, field }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    uppercase: ({ shape, value: on, field }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    lowercase: ({ shape, value: on, field }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    localized: ({ shape, value: on, field }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    required: ({ shape, value: on, field }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    defaultValue: ({ shape }: {
+        shape: z.ZodType;
+        value: Date | readonly unknown[] | import("../index.ts").Ref | import("../index.ts").Json;
+        field: ResolvedField;
+    }) => z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    /** The moment the defaults step writes, which leaves the key optional as a literal does. */
+    defaultNow: ({ shape, value: on }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** Filled on update by the defaults step, and never client-supplied there, so nothing to shape. */
+    nowOnUpdate: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+};

package/dist/zod/rules.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { compareDecimals, decimalDigits } from '../base/decimal.js';
+import { errorOf } from './kinds.js';
+// One copy key per field per rule, with no number in it: the browser already
+// holds the field's rules for any number it shows.
+const keyOf = (field, rule) => field.kayan ? `${field.kayan}.${field.name}.${rule}` : undefined;
+// `required`, `defaultValue` and `defaultNow` come last: an optional shape is a
+// `ZodOptional` with none of the narrowing methods left on it.
+export const rules = {
+    /** The database enforces it, and only the database can. */
+    unique: ({ shape }) => shape,
+    /** Nothing about reading rows faster changes what a write must look like. */
+    index: ({ shape }) => shape,
+    /** A rule about deleting the other row, and a write is not a delete. */
+    onDelete: ({ shape }) => shape,
+    // Read where the objects are assembled: a field the client does not supply is
+    // absent from that shape, so the strict object refuses a caller that sends it.
+    providedBy: ({ shape }) => shape,
+    minLength: ({ shape, value: length, field }) => shape.min(length, { error: keyOf(field, 'minLength') }),
+    maxLength: ({ shape, value: length, field }) => shape.max(length, { error: keyOf(field, 'maxLength') }),
+    pattern: ({ shape, value: expression, field }) => shape.regex(expression, { error: keyOf(field, 'pattern') }),
+    // Counted as `numeric(precision, scale)` counts, so Postgres never rounds a value or refuses it as a 500.
+    precision: ({ shape, value: precision, field }) => shape.refine((held) => {
+        const { whole, fraction } = decimalDigits(String(held));
+        return whole + fraction <= precision && whole <= precision - Number(field.rules?.scale);
+    }, { error: keyOf(field, 'precision') }),
+    scale: ({ shape, value: scale, field }) => shape.refine((held) => decimalDigits(String(held)).fraction <= scale, { error: keyOf(field, 'scale') }),
+    // `min` on a string shape is a length, so an ISO day gets a check of its own.
+    min: ({ shape, value, field }) => typeof value === 'number'
+        ? shape.min(value, { error: keyOf(field, 'min') })
+        : shape.refine((held) => (field.kind === 'decimal' ? compareDecimals(String(held), value) >= 0 : String(held) >= value), {
+            error: keyOf(field, 'min') ?? `Too small: expected value to be >=${value}`,
+        }),
+    max: ({ shape, value, field }) => typeof value === 'number'
+        ? shape.max(value, { error: keyOf(field, 'max') })
+        : shape.refine((held) => (field.kind === 'decimal' ? compareDecimals(String(held), value) <= 0 : String(held) <= value), {
+            error: keyOf(field, 'max') ?? `Too big: expected value to be <=${value}`,
+        }),
+    // An empty list passes the floor unless the field is `required`.
+    minRows: ({ shape, value: rows, field }) => shape.refine((held) => held.length >= rows || (!field.rules?.required && !held.length), {
+        error: keyOf(field, 'minRows') ?? `Too small: expected array to have >=${rows} items`,
+    }),
+    maxRows: ({ shape, value: rows, field }) => shape.max(rows, { error: keyOf(field, 'maxRows') }),
+    // Piped in front of what the kind and earlier rules built, so `maxLength` and
+    // `z.email()` judge the trimmed value; before `localized`, so each locale is trimmed.
+    trim: ({ shape, value: on, field }) => (on ? z.string({ error: errorOf(field) }).trim().pipe(shape) : shape),
+    uppercase: ({ shape, value: on, field }) => (on ? z.string({ error: errorOf(field) }).toUpperCase().pipe(shape) : shape),
+    lowercase: ({ shape, value: on, field }) => (on ? z.string({ error: errorOf(field) }).toLowerCase().pipe(shape) : shape),
+    // After every narrowing rule and before `required`: rules apply to each locale's
+    // value, and a field nobody wrote is one null rather than an object of them.
+    localized: ({ shape, value: on, field }) => on ? z.strictObject(Object.fromEntries(field.locales.map((locale) => [locale, shape]))) : shape,
+    // A required text refuses the empty string too. A required `textArray` may be
+    // empty; `minRows: 1` refuses that.
+    required: ({ shape, value: on, field }) => field.name === 'id'
+        ? shape
+        : !on
+            ? shape.nullable().optional()
+            : field.kind === 'text'
+                ? shape.refine((held) => !(field.rules?.localized ? Object.values(held) : [held]).includes(''), { error: keyOf(field, 'required') })
+                : shape,
+    // Optional, not nullable: the runner fills every default on every write that makes or changes a row.
+    defaultValue: ({ shape }) => shape.optional(),
+    /** The moment the defaults step writes, which leaves the key optional as a literal does. */
+    defaultNow: ({ shape, value: on }) => (on ? shape.optional() : shape),
+    /** Filled on update by the defaults step, and never client-supplied there, so nothing to shape. */
+    nowOnUpdate: ({ shape }) => shape,
+};