mirror of
https://github.com/Start9Labs/start-os.git
synced 2026-03-26 10:21:52 +00:00
93 lines
3.0 KiB
JavaScript
93 lines
3.0 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
|
const zod_1 = require("zod");
|
|
const zod_deep_partial_1 = require("zod-deep-partial");
|
|
|
|
// Recursively make all ZodObjects in a schema loose (preserve extra keys at every nesting level).
|
|
// Uses _zod.def.type duck-typing instead of instanceof to avoid issues with mismatched zod versions.
|
|
function deepLoose(schema) {
|
|
const def = schema._zod?.def;
|
|
if (!def) return schema;
|
|
let result;
|
|
switch (def.type) {
|
|
case "optional":
|
|
result = deepLoose(def.innerType).optional();
|
|
break;
|
|
case "nullable":
|
|
result = deepLoose(def.innerType).nullable();
|
|
break;
|
|
case "object": {
|
|
const newShape = {};
|
|
for (const key in schema.shape) {
|
|
newShape[key] = deepLoose(schema.shape[key]);
|
|
}
|
|
result = zod_1.z.looseObject(newShape);
|
|
break;
|
|
}
|
|
case "array":
|
|
result = zod_1.z.array(deepLoose(def.element));
|
|
break;
|
|
case "union":
|
|
result = zod_1.z.union(def.options.map((o) => deepLoose(o)));
|
|
break;
|
|
case "intersection":
|
|
result = zod_1.z.intersection(deepLoose(def.left), deepLoose(def.right));
|
|
break;
|
|
case "record":
|
|
result = zod_1.z.record(def.keyType, deepLoose(def.valueType));
|
|
break;
|
|
case "tuple":
|
|
result = zod_1.z.tuple(def.items.map((i) => deepLoose(i)));
|
|
break;
|
|
case "lazy":
|
|
result = zod_1.z.lazy(() => deepLoose(def.getter()));
|
|
break;
|
|
default:
|
|
return schema;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Add deepPartial and deepLoose to z at runtime
|
|
zod_1.z.deepPartial = (a) =>
|
|
deepLoose((0, zod_deep_partial_1.zodDeepPartial)(a));
|
|
zod_1.z.deepLoose = deepLoose;
|
|
|
|
// Override z.object to produce loose objects by default (extra keys are preserved, not stripped).
|
|
const _origObject = zod_1.z.object;
|
|
const _patchedObject = (...args) => _origObject(...args).loose();
|
|
|
|
// In CJS (Node.js), patch the source module in require.cache where 'object' is a writable property;
|
|
// the CJS getter chain (index → external → schemas) then relays the patched version.
|
|
// We walk only the zod entry module's dependency tree and match by identity (=== origObject).
|
|
try {
|
|
const _zodModule = require.cache[require.resolve("zod")];
|
|
for (const child of _zodModule?.children ?? []) {
|
|
for (const grandchild of child.children ?? []) {
|
|
const desc = Object.getOwnPropertyDescriptor(
|
|
grandchild.exports,
|
|
"object",
|
|
);
|
|
if (desc?.value === _origObject && desc.writable) {
|
|
grandchild.exports.object = _patchedObject;
|
|
}
|
|
}
|
|
}
|
|
} catch (_) {
|
|
// Not in CJS/Node environment (e.g. browser) — require.cache unavailable
|
|
}
|
|
|
|
// z.object is a non-configurable getter on the zod namespace, so we can't override it directly.
|
|
// Shadow it by exporting a new object with _z as prototype and our patched object on the instance.
|
|
const z = Object.create(zod_1.z, {
|
|
object: {
|
|
value: _patchedObject,
|
|
writable: true,
|
|
configurable: true,
|
|
enumerable: true,
|
|
},
|
|
});
|
|
|
|
exports.z = z;
|