@peers-app/peers-sdk 0.26.6 → 0.27.0

package/dist/define/empty-fields.d.ts

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+/**
+ * `value` without the empty fields `schema` lets a caller leave out, before the schema parses
+ * it: a field that is `null` or `undefined` and is `.optional()` or has a default is removed, in
+ * nested objects too (including each object in an array). Peers has one empty value, a missing
+ * field, so `.optional()` and defaults then see a missing field rather than refusing a `null`.
+ * Other fields, and values the schema doesn't describe as objects, are left as they are. Returns
+ * `value` itself when nothing is removed, and a copy otherwise; `value` is never changed.
+ *
+ * @internal
+ * @param schema - A tool's input or output, a table's row, an event's payload, or an
+ *   observable's value schema.
+ * @param value - The value about to be parsed or sent.
+ */
+export declare function withoutEmptySchemaFields(schema: z.ZodTypeAny | undefined, value: unknown): unknown;

package/dist/define/empty-fields.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withoutEmptySchemaFields = withoutEmptySchemaFields;
+/**
+ * `value` without the empty fields `schema` lets a caller leave out, before the schema parses
+ * it: a field that is `null` or `undefined` and is `.optional()` or has a default is removed, in
+ * nested objects too (including each object in an array). Peers has one empty value, a missing
+ * field, so `.optional()` and defaults then see a missing field rather than refusing a `null`.
+ * Other fields, and values the schema doesn't describe as objects, are left as they are. Returns
+ * `value` itself when nothing is removed, and a copy otherwise; `value` is never changed.
+ *
+ * @internal
+ * @param schema - A tool's input or output, a table's row, an event's payload, or an
+ *   observable's value schema.
+ * @param value - The value about to be parsed or sent.
+ */
+function withoutEmptySchemaFields(schema, value) {
+    if (!schema) {
+        return value;
+    }
+    const root = walkField(schema);
+    const shape = objectShape(root.base);
+    // An observable's whole value may be an array; its object elements still have fields.
+    if (shape && root.isArray && Array.isArray(value)) {
+        return withoutEmptyItems(root.base, value);
+    }
+    if (!shape || !isPlainRecord(value)) {
+        return value;
+    }
+    let copy;
+    for (const [name, fieldSchema] of Object.entries(shape)) {
+        if (!Object.hasOwn(value, name)) {
+            continue;
+        }
+        const current = value[name];
+        const { mayBeMissing, base, isArray } = walkField(fieldSchema);
+        let next = current;
+        if (current === null || current === undefined) {
+            if (!mayBeMissing) {
+                continue;
+            }
+            next = undefined;
+        }
+        else if (objectShape(base)) {
+            next =
+                isArray && Array.isArray(current)
+                    ? withoutEmptyItems(base, current)
+                    : withoutEmptySchemaFields(base, current);
+        }
+        if (next === current && next !== undefined) {
+            continue;
+        }
+        copy ??= { ...value };
+        if (next === undefined) {
+            delete copy[name];
+        }
+        else {
+            // Define rather than assign, so a "__proto__" field stays a field.
+            Object.defineProperty(copy, name, {
+                value: next,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        }
+    }
+    return copy ?? value;
+}
+function withoutEmptyItems(schema, items) {
+    let copy;
+    items.forEach((item, index) => {
+        const next = withoutEmptySchemaFields(schema, item);
+        if (next !== item) {
+            copy ??= [...items];
+            copy[index] = next;
+        }
+    });
+    return copy ?? items;
+}
+/** Walk the wrappers the manifest walks, and one array, without running schema code. */
+function walkField(schema) {
+    let current = schema;
+    let mayBeMissing = false;
+    let isArray = false;
+    while (true) {
+        const def = current._def;
+        switch (def.typeName) {
+            case "ZodOptional":
+            case "ZodDefault":
+            case "ZodCatch":
+                mayBeMissing ||= !isArray;
+                current = def.innerType;
+                continue;
+            case "ZodNullable":
+            case "ZodReadonly":
+                current = def.innerType;
+                continue;
+            case "ZodBranded":
+                current = def.type;
+                continue;
+            case "ZodEffects":
+                if (def.effect.type !== "refinement") {
+                    // The input can still be left out behind an effect, as the manifest's input IR
+                    // records. Keep the value opaque: don't clean object fields across a transform.
+                    return {
+                        mayBeMissing: mayBeMissing || (!isArray && walkField(def.schema).mayBeMissing),
+                        base: current,
+                        isArray,
+                    };
+                }
+                current = def.schema;
+                continue;
+            case "ZodArray":
+                if (isArray) {
+                    return { mayBeMissing, base: current, isArray };
+                }
+                isArray = true;
+                current = def.type;
+                continue;
+            default:
+                return { mayBeMissing, base: current, isArray };
+        }
+    }
+}
+function objectShape(schema) {
+    return schema._def.typeName === "ZodObject" ? schema.shape : undefined;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/define/empty-fields.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/define/empty-fields.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const empty_fields_1 = require("./empty-fields");
+test("undefined fields are absent before author refinements run", () => {
+    const item = zod_1.z
+        .object({ note: zod_1.z.string().optional() })
+        .refine((value) => !Object.hasOwn(value, "note"));
+    const schema = zod_1.z.object({ item, items: zod_1.z.array(item), rank: zod_1.z.number().default(5) });
+    const input = { item: { note: undefined }, items: [{ note: undefined }], rank: null };
+    const cleaned = (0, empty_fields_1.withoutEmptySchemaFields)(schema, input);
+    expect(cleaned).toStrictEqual({ item: {}, items: [{}] });
+    expect(schema.parse(cleaned)).toStrictEqual({ item: {}, items: [{}], rank: 5 });
+    expect(input.item).toHaveProperty("note");
+});
+test("an array value's object fields are cleaned, while its empty elements are kept", () => {
+    const schema = zod_1.z.array(zod_1.z.object({ note: zod_1.z.string().optional() }).nullable()).readonly();
+    const input = [{ note: null }, null, { note: undefined }, { note: "set" }];
+    const cleaned = (0, empty_fields_1.withoutEmptySchemaFields)(schema, input);
+    expect(cleaned).toStrictEqual([{}, null, {}, { note: "set" }]);
+    expect(schema.parse(cleaned)).toStrictEqual(cleaned);
+    expect(input[0]).toStrictEqual({ note: null });
+});
+test("undescribed values retain nulls and required fields remain for validation", () => {
+    const schema = zod_1.z.object({
+        required: zod_1.z.string(),
+        data: zod_1.z.unknown(),
+        record: zod_1.z.record(zod_1.z.unknown()),
+    });
+    const input = { required: null, data: { note: null }, record: { note: null } };
+    expect((0, empty_fields_1.withoutEmptySchemaFields)(schema, input)).toBe(input);
+    expect(schema.safeParse((0, empty_fields_1.withoutEmptySchemaFields)(schema, input)).success).toBe(false);
+});
+test("an effect can accept a missing input without describing its inner object fields", () => {
+    const schema = zod_1.z.object({
+        rank: zod_1.z
+            .number()
+            .optional()
+            .transform((value) => value ?? 5),
+        opaque: zod_1.z.object({ note: zod_1.z.string().nullish() }).transform((value) => value),
+        items: zod_1.z.array(zod_1.z
+            .string()
+            .optional()
+            .transform((value) => value ?? "")),
+    });
+    const input = { rank: null, opaque: { note: null }, items: null };
+    const cleaned = (0, empty_fields_1.withoutEmptySchemaFields)(schema, input);
+    expect(cleaned).toStrictEqual({ opaque: { note: null }, items: null });
+    expect(schema.safeParse(cleaned).success).toBe(false);
+    expect(schema.parse({ ...cleaned, items: [] })).toStrictEqual({
+        rank: 5,
+        opaque: { note: null },
+        items: [],
+    });
+});

package/dist/define/events-observables.test.d.ts

@@ -0,0 +1 @@
+export {};