zodselect 1.2.0 → 1.2.1

package/dist/build-select-object.d.ts

@@ -1,12 +1,17 @@
 import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodObject, ZodOptional, ZodRawShape, ZodType, ZodUnion } from 'zod';
+import { UnionToIntersection } from './refine-schema.js';
 import { ZodSelect } from './select.js';
 type Depth = [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type FieldSelectAll<T, TDepth extends number> = TDepth extends 0 ? true : Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, Depth[TDepth]> : Unwrap<T> extends ZodArray<infer TItem> ? Unwrap<TItem> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, Depth[TDepth]> : true : true;
+type FieldSelectAll<T, TDepth extends number> = TDepth extends 0 ? true : Unwrap<T> extends ZodArray<infer TItem> ? ItemSelectAll<TItem, Depth[TDepth]> : ItemSelectAll<T, Depth[TDepth]>;
+type ItemSelectAll<T, TDepth extends number> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, TDepth> : Unwrap<T> extends ZodUnion<infer TOptions> ? UnionShape<TOptions> extends infer TShape extends ZodRawShape ? ObjectSelectAll<TShape, TDepth> : true : true;
 type ObjectSelectAll<TShape extends ZodRawShape, TDepth extends number> = {
     [K in keyof TShape]-?: FieldSelectAll<TShape[K], TDepth>;
 };
+type ShapeOf<T> = T extends unknown ? Unwrap<T> extends ZodObject<infer TShape, any> ? TShape : never : never;
+/** The shapes of a union's object variants, merged; `unknown` when it has none. */
+type UnionShape<TOptions> = UnionToIntersection<TOptions extends readonly (infer TOption)[] ? ShapeOf<TOption> : never>;
 type Unwrap<T> = T extends ZodCatch<infer I> | ZodDefault<infer I> | ZodNullable<infer I> | ZodOptional<infer I> ? Unwrap<I> : T extends ZodLazy<infer I> ? Unwrap<I> : T;
-/** What {@link buildSelectObject} answers: nested for objects and arrays of objects, `true` for anything else. */
+/** What {@link buildSelectObject} answers: nested for objects, unions with an object variant, and arrays of either; `true` for anything else. */
 export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> extends ZodObject<infer TShape, any> ? ObjectSelectAll<TShape, 10> : {
     [K in keyof ZodSelect<T, true>]-?: true;
 };
@@ -14,8 +19,10 @@ export type ZodSelectAll<T extends ZodType<object> | ZodUnion> = Unwrap<T> exten
  * Produces a runtime select-all object for the given Zod schema.
  *
  * Every scalar key is set to `true`. Nested object fields, and arrays of
- * objects, are recursively expanded into nested select objects. Other arrays
- * and records remain `true`.
+ * objects, are recursively expanded into nested select objects. A union field
+ * with an object variant, such as a file stored as an id and read as the file,
+ * expands into the merged keys of its object variants. Other arrays and
+ * records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example

package/dist/build-select-object.js

@@ -4,8 +4,10 @@ import { getInnerType, isZodArray, isZodObject, isZodUnion } from './utilities.j
  * Produces a runtime select-all object for the given Zod schema.
  *
  * Every scalar key is set to `true`. Nested object fields, and arrays of
- * objects, are recursively expanded into nested select objects. Other arrays
- * and records remain `true`.
+ * objects, are recursively expanded into nested select objects. A union field
+ * with an object variant, such as a file stored as an id and read as the file,
+ * expands into the merged keys of its object variants. Other arrays and
+ * records remain `true`.
  * For union schemas the result is the merged set of keys across all variants.
  *
  * @example
@@ -44,7 +46,7 @@ function collectKeys(schema, result, depth = 0) {
         for (const key in schema.shape) {
             const field = unwrapField(schema.shape[key]);
             const fieldInner = isZodArray(field) ? unwrapField(field.def.element) : field;
-            if (isZodObject(fieldInner)) {
+            if (isZodObject(fieldInner) || hasObjectVariant(fieldInner)) {
                 const nested = {};
                 collectKeys(fieldInner, nested, depth + 1);
                 result[key] = nested;
@@ -64,3 +66,6 @@ function collectKeys(schema, result, depth = 0) {
         collectKeys(schema.def.right, result, depth);
     }
 }
+function hasObjectVariant(schema) {
+    return isZodUnion(schema) && schema.options.some(option => isZodObject(unwrapField(option)));
+}

package/dist/build-select-object.spec.js

@@ -141,13 +141,57 @@ describe('.buildSelectObject()', () => {
         const schema = z.object({
             byKey: z.record(z.string(), z.object({ id: z.string() })),
             matrix: z.array(z.array(z.number())),
-            options: z.array(z.union([z.object({ a: z.string() }), z.object({ b: z.string() })])),
             tags: z.array(z.string())
         });
         const select = buildSelectObject(schema);
         const isTyped = true;
         assert.ok(isTyped);
-        assert.deepStrictEqual(select, { byKey: true, matrix: true, options: true, tags: true });
+        assert.deepStrictEqual(select, { byKey: true, matrix: true, tags: true });
+    });
+    it('should expand a union field into the keys of its object variants', () => {
+        const schema = z.object({
+            file: z.union([z.object({ _id: z.string(), filename: z.string() }), z.string()]),
+            name: z.string()
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { file: { _id: true, filename: true }, name: true });
+    });
+    it('should merge the keys of every object variant of a union field', () => {
+        const schema = z.object({
+            party: z.union([z.object({ name: z.string(), type: z.literal('company') }), z.object({ first: z.string(), type: z.literal('person') })]).optional()
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { party: { first: true, name: true, type: true } });
+    });
+    it('should not expand a union field with no object variant', () => {
+        const schema = z.object({ value: z.union([z.string(), z.number()]).nullable() });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { value: true });
+    });
+    it('should expand an array of a union of objects', () => {
+        const schema = z.object({
+            options: z.array(z.union([z.object({ a: z.string() }), z.object({ b: z.string() })]))
+        });
+        const select = buildSelectObject(schema);
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { options: { a: true, b: true } });
+    });
+    it('should expand an attachment whose file is stored as an id and read as the file', () => {
+        const file = z.object({ _id: z.string(), contentType: z.string().optional(), filename: z.string() });
+        const revision = z.object({ file: z.union([file, z.string()]), uploadedBy: z.object({ _id: z.string(), username: z.string() }) });
+        const schema = z.object({ attachments: z.array(revision.extend({ history: z.array(revision).optional(), title: z.string().optional() })).optional() });
+        const select = buildSelectObject(schema);
+        const revisionSelect = { file: { _id: true, contentType: true, filename: true }, uploadedBy: { _id: true, username: true } };
+        const isTyped = true;
+        assert.ok(isTyped);
+        assert.deepStrictEqual(select, { attachments: { ...revisionSelect, history: revisionSelect, title: true } });
     });
     it('should be a select the schema accepts', () => {
         const schema = z.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zodselect",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Type-safe selection utility built on top of Zod. Allows for strongly typed field selection, schema merging, and runtime refinement for frontend or backend use.",
   "author": "SecureDataSystems",
   "license": "MIT",