zerodrift 1.0.3 → 1.1.0

package/dist/schema/zod.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { AnyFieldBuilder, EntityDef, FieldBuilder } from "./types";
+import type { AnyFieldBuilder, EntityDef, FieldBuilder, FieldKind, FieldMeta } from "./types.js";
 /**
  * Convert any Zod schema into the equivalent schema-first `FieldBuilder`.
  * Handles the common nullable / optional / default modifiers; anything more
@@ -10,31 +10,111 @@ import type { AnyFieldBuilder, EntityDef, FieldBuilder } from "./types";
  * caller to have installed `zod`.
  */
 export declare function fromZod<Z extends z.ZodType>(zSchema: Z): FieldBuilder<z.infer<Z>>;
+/**
+ * Maps Zod's `_zod.def.type` discriminator to a schema `FieldKind`. Mirrors
+ * the runtime `PRIMITIVE_KIND` map; anything not covered collapses to `"json"`,
+ * matching `fromZod`'s fallback.
+ */
+type ZodKindFromTypeName<T> = T extends "string" ? "string" : T extends "number" | "int" ? "number" : T extends "boolean" ? "boolean" : T extends "date" ? "date" : "json";
+/**
+ * Type-level analogue of `fromZod`'s runtime walker: peels off `nullable` /
+ * `optional` / `default` wrappers, stamping each on the accumulator, then
+ * collapses the leaf to a kind via `ZodKindFromTypeName`. The result is
+ * intersected with `FieldMeta` so `IsOptionalCreateField` sees the same
+ * `{kind, optional, default}` flags the runtime produces — keeping
+ * create-input optionality aligned for `.optional()` and `.default(...)`
+ * Zod fields, not just `id`.
+ */
+type ZodToFieldMeta<Z, Accum = Record<never, never>> = Z extends {
+    _zod: {
+        def: {
+            type: "nullable";
+            innerType: infer I;
+        };
+    };
+} ? ZodToFieldMeta<I, Accum & {
+    nullable: true;
+}> : Z extends {
+    _zod: {
+        def: {
+            type: "optional";
+            innerType: infer I;
+        };
+    };
+} ? ZodToFieldMeta<I, Accum & {
+    optional: true;
+}> : Z extends {
+    _zod: {
+        def: {
+            type: "default";
+            innerType: infer I;
+        };
+    };
+} ? ZodToFieldMeta<I, Accum & {
+    default: unknown;
+}> : Z extends {
+    _zod: {
+        def: {
+            type: infer T extends string;
+        };
+    };
+} ? Accum & {
+    kind: ZodKindFromTypeName<T>;
+} : Accum;
+/** Empty meta marker — convention-driven flags (autoIndex) layer on top.
+ * `id` is excluded because the storage layer treats the PK specially and
+ * never materializes a secondary index for it; the empty-string suffix is
+ * excluded so a defaulted/blank config value doesn't index every field. */
+type AutoIndexMeta<K, AI extends string | undefined> = K extends "id" ? Record<never, never> : AI extends "" ? Record<never, never> : AI extends string ? K extends `${string}${AI}` ? {
+    indexed: true;
+} : Record<never, never> : Record<never, never>;
+/**
+ * Auto-derived `FieldBuilder` type for a Zod-object key. The `id` key is
+ * special-cased to carry `{kind: "id"}` (the runtime routes `id` through
+ * `fields.id()` regardless of the Zod-declared id type). Every other key
+ * walks its Zod schema via `ZodToFieldMeta` so PK, optional, and default
+ * flags all flow into the field's create-input optionality the same way.
+ * `AI` is the opts.autoIndex suffix — matching keys pick up `{indexed: true}`.
+ */
+type AutoFieldFromZod<K, ZS, AI extends string | undefined = undefined> = K extends "id" ? FieldBuilder<string, FieldMeta & {
+    kind: "id";
+} & AutoIndexMeta<K, AI>> : ZS extends z.ZodType ? FieldBuilder<z.infer<ZS>, FieldMeta & ZodToFieldMeta<ZS> & AutoIndexMeta<K, AI>> : FieldBuilder<unknown, FieldMeta & {
+    kind: FieldKind;
+}>;
 /**
  * Per-field override for `entityFromZod`. Either a chaining function
  * (modifies the auto-derived `FieldBuilder`) or a full `FieldBuilder`
  * (replaces it — useful for FKs and other shapes Zod can't model).
  */
 export type EntityFromZodFieldOverride<AutoT = unknown> = AnyFieldBuilder | ((auto: FieldBuilder<AutoT>) => AnyFieldBuilder);
-type EntityFromZodFieldOverrides<Z extends z.ZodObject> = {
-    [K in keyof z.infer<Z> & string]?: AnyFieldBuilder | ((auto: FieldBuilder<z.infer<Z>[K]>) => unknown);
+type EntityFromZodFieldOverrides<Z extends z.ZodObject, AI extends string | undefined = undefined> = {
+    [K in keyof Z["shape"] & string]?: AnyFieldBuilder | ((auto: AutoFieldFromZod<K, Z["shape"][K], AI>) => unknown);
+};
+/**
+ * Maps any `opts.fields` key that isn't declared on the Zod object to a
+ * branded error-string type. The intersection with the override map then
+ * forces TS to surface "is not assignable to type \"Error: 'foo' is not a
+ * field…\"" — naming the offender — instead of the bare "not assignable to
+ * type 'never'" the previous `Record<…, never>` form produced.
+ */
+type NoExtraZodFieldKeys<Z extends z.ZodObject, F> = {
+    [K in keyof F as K extends keyof Z["shape"] ? never : K]: `Error: '${K & string}' is not a field declared on the Zod object passed to entityFromZod`;
 };
-type NoExtraZodFieldKeys<Z extends z.ZodObject, F> = Record<Exclude<keyof F, keyof z.infer<Z> & string>, never>;
 /**
  * Resolve the field type contributed by an override entry. Functions are
  * unwrapped via their inferred return type so chained modifiers like
  * `.indexed()` carry their narrowed `M` into the entity's inferred fields;
  * direct `FieldBuilder` overrides are used as-is. When no override is
- * provided the auto-derived `FieldBuilder<AutoT>` from Zod stands.
+ * provided the auto-derived `Auto` field stands.
  */
-type FieldFromOverride<O, AutoT> = O extends (...args: never[]) => infer R ? R extends FieldBuilder<infer RT, infer RM> ? [unknown] extends [RT] ? FieldBuilder<AutoT, RM> : R : FieldBuilder<AutoT> : O extends AnyFieldBuilder ? O : FieldBuilder<AutoT>;
+type FieldFromOverride<O, Auto> = O extends (...args: never[]) => infer R ? R extends FieldBuilder<infer RT, infer RM> ? [unknown] extends [RT] ? Auto extends FieldBuilder<infer AT, FieldMeta> ? FieldBuilder<AT, RM> : never : R : Auto : O extends AnyFieldBuilder ? O : Auto;
 /**
  * Per-key merge of the Zod-inferred fields with `opts.fields` overrides.
  * Override metadata (`.indexed()`, refId target, …) propagates into the
  * entity's TS type so downstream helpers like `IndexedFieldKeys` see them.
  */
-type MergedFieldsFromZodObject<Z extends z.ZodObject, F> = {
-    [K in keyof z.infer<Z>]: K extends keyof F ? FieldFromOverride<F[K], z.infer<Z>[K]> : FieldBuilder<z.infer<Z>[K]>;
+type MergedFieldsFromZodObject<Z extends z.ZodObject, F, Om extends readonly string[] = readonly [], AI extends string | undefined = undefined> = {
+    [K in keyof Z["shape"] as K extends Om[number] ? never : K]: K extends keyof F ? FieldFromOverride<F[K], AutoFieldFromZod<K, Z["shape"][K], AI>> : AutoFieldFromZod<K, Z["shape"][K], AI>;
 };
 /** Non-`fields` portion of the opts — shared across the public type and
  * the function's inferred-`F` signature. Tracks `EntityDef` so any new
@@ -56,8 +136,15 @@ export interface EntityFromZodOpts<Z extends z.ZodObject = z.ZodObject> extends
      *     });
      */
     fields?: {
-        [K in keyof z.infer<Z> & string]?: EntityFromZodFieldOverride<z.infer<Z>[K]>;
+        [K in keyof Z["shape"] & string]?: AnyFieldBuilder | ((auto: AutoFieldFromZod<K, Z["shape"][K]>) => AnyFieldBuilder);
     };
+    /** Fields whose Zod name ends with this suffix pick up `.indexed()` —
+     * intended for the common FK-naming convention (`/ID$/` → `autoIndex: "ID"`).
+     * Suppressed for any key that supplies a builder-form override. */
+    autoIndex?: string;
+    /** Field names to drop entirely from the produced entity. Common when the
+     * source Zod was generated from a DTO that carries transport-only keys. */
+    omit?: readonly string[];
 }
 /**
  * Convert a `z.object({ ... })` into an `EntityDef`. Each key on the Zod
@@ -84,7 +171,33 @@ export interface EntityFromZodOpts<Z extends z.ZodObject = z.ZodObject> extends
  * shape and validation; `link(...)` remains the source of truth for the
  * graph.
  */
-export declare function entityFromZod<Z extends z.ZodObject, const F = Record<never, never>>(zSchema: Z, opts: EntityFromZodOptsBase & {
-    fields?: F & EntityFromZodFieldOverrides<Z> & NoExtraZodFieldKeys<Z, F>;
-}): EntityDef<MergedFieldsFromZodObject<Z, F>>;
+export declare function entityFromZod<Z extends z.ZodObject, const F = Record<never, never>, const Om extends readonly (keyof Z["shape"] & string)[] = readonly [], const AI extends string | undefined = undefined>(zSchema: Z, opts: EntityFromZodOptsBase & {
+    fields?: F & EntityFromZodFieldOverrides<Z, AI> & NoExtraZodFieldKeys<Z, F>;
+    autoIndex?: AI;
+    omit?: Om;
+}): EntityDef<MergedFieldsFromZodObject<Z, F, Om, AI>>;
+/**
+ * Map a whole `{key: ZodObject}` module (e.g. an OpenAPI-generated barrel)
+ * into an entities record by calling `entityFromZod` per key with shared
+ * opts. The entity key in the returned record is the input key; the registry
+ * name is auto-derived (PascalCase of the key) by `compileSchema` — no need
+ * to spell `name` per entity.
+ *
+ *     const entities = entitiesFromZod(generatedZods, {
+ *       loadStrategy: LoadStrategy.Eager,
+ *       autoIndex: "ID",
+ *       omit: ["createdAt", "updatedAt"],
+ *     });
+ *     const schema = defineSchema({ entities, links: { ... } });
+ *
+ * Per-entity overrides are not threaded — drop down to `entityFromZod` for
+ * the handful that need a custom `fields` map or distinct `loadStrategy`.
+ */
+type EntitiesFromZodResult<Zods extends Record<string, z.ZodObject>, Om extends readonly string[], AI extends string | undefined> = {
+    [K in keyof Zods]: EntityDef<MergedFieldsFromZodObject<Zods[K], Record<never, never>, Om, AI>>;
+};
+export declare function entitiesFromZod<Zods extends Record<string, z.ZodObject>, const Om extends readonly string[] = readonly [], const AI extends string | undefined = undefined>(zods: Zods, opts: Pick<EntityFromZodOptsBase, "loadStrategy" | "usedForPartialIndexes"> & {
+    autoIndex?: AI;
+    omit?: Om;
+}): EntitiesFromZodResult<Zods, Om, AI>;
 export {};

package/dist/schema/zod.js

@@ -1,4 +1,4 @@
-import { fields, entity, rebuildFieldBuilder } from "./builders";
+import { fields, entity, rebuildFieldBuilder } from "./builders.js";
 const PRIMITIVE_KIND = new Map([
     ["string", fields.string],
     ["number", fields.number],
@@ -82,9 +82,19 @@ export function fromZod(zSchema) {
  */
 export function entityFromZod(zSchema, opts) {
     const overrides = (opts.fields ?? {});
+    const omitted = new Set(opts.omit ?? []);
+    const autoIndexSuffix = opts.autoIndex != null && opts.autoIndex !== "" ? opts.autoIndex : null;
     const fieldsRecord = {};
     for (const [key, fieldSchema] of Object.entries(zSchema.shape)) {
-        const auto = key === "id" ? fields.id() : fromZod(fieldSchema);
+        if (omitted.has(key)) {
+            continue;
+        }
+        let auto = key === "id" ? fields.id() : fromZod(fieldSchema);
+        if (autoIndexSuffix != null &&
+            key !== "id" &&
+            key.endsWith(autoIndexSuffix)) {
+            auto = auto.indexed();
+        }
         const override = overrides[key];
         fieldsRecord[key] =
             typeof override === "function"
@@ -99,3 +109,15 @@ export function entityFromZod(zSchema, opts) {
         fields: fieldsRecord,
     });
 }
+export function entitiesFromZod(zods, opts) {
+    const out = {};
+    for (const [key, zod] of Object.entries(zods)) {
+        out[key] = entityFromZod(zod, {
+            loadStrategy: opts.loadStrategy,
+            usedForPartialIndexes: opts.usedForPartialIndexes,
+            autoIndex: opts.autoIndex,
+            omit: opts.omit,
+        });
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zerodrift",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "private": false,
   "description": "A TypeScript local-first sync engine: synchronous in-memory reads, optimistic writes, realtime SSE sync, offline IndexedDB persistence. Runs in the browser and in Node.",
   "license": "MIT",