New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

zongo

Package Overview
Dependencies
Maintainers
1
Versions
31
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

zongo - npm Package Compare versions

Comparing version

0.0.18
to
0.0.19

49

dist/schema/zEmbeddedSchema.d.ts

@@ -1,40 +0,25 @@

/// <reference types="node" />
import { ObjectId } from "mongodb";
import { ParseInput, ParseReturnType, z, ZodBrandedDef, ZodType } from "zod";
import { ZCollectionDefinition, ZCollectionModelName, ZCollectionUnbranded } from "../types/ZCollectionDefinition";
import { AsyncParseReturnType, ParseInput, z, ZodType } from "zod";
import { ZCollectionDefinition, ZCollectionUnbranded } from "../types/ZCollectionDefinition";
import { ResolveZReferences } from "../types/ZDatabase";
import { ZDocumentReference } from "../types/ZDocumentReference";
import { Thunk } from "../util";
type RemoveBrand<T> = T extends z.ZodBranded<infer S, any> ? S : never;
export declare const DEF_NAME_SYM: unique symbol;
type DefNameBrand<DefName extends string> = {
[DEF_NAME_SYM]: DefName;
};
export declare class ZSchemaReferenceWrapper<Schema extends z.ZodSchema, Definition extends ZCollectionDefinition<any, z.ZodSchema>> extends ZodType<Schema["_output"] & DefNameBrand<ZCollectionModelName<Definition>>, ZodBrandedDef<Schema>, Schema["_input"] & DefNameBrand<ZCollectionModelName<Definition>>> {
export declare class ZSchemaReferenceWrapper<Definition extends ZCollectionDefinition<any, z.ZodSchema>, Mask extends Record<string, true | undefined> | undefined = undefined, ExistingData extends Record<string, any> = {}> extends ZodType<ZDocumentReference<Definition, Mask, ExistingData>, {}, ObjectId | {
_id: ObjectId;
} | ZDocumentReference<any, any, any>> {
definition: Definition;
mask: string[] | undefined;
constructor(definition: Definition, mask: string[] | undefined, def: z.ZodBrandedDef<any>);
_parse(input: ParseInput): ParseReturnType<any>;
mask: Mask;
constructor(definition: Definition, mask: Mask);
_parse(input: ParseInput): AsyncParseReturnType<ZDocumentReference<any, any, any>>;
}
type UnionOfKeys<T> = T extends any ? keyof T : never;
type DistributiveSelectivePick<T, K extends keyof T> = T extends unknown ? {
[Key in keyof Pick<T, Extract<K, keyof T>>]: Pick<T, K>[Key];
} : never;
export declare const zEmbeddedSchema: {
full: <Definition extends ZCollectionDefinition<any, z.ZodType<any, z.ZodTypeDef, any>>>(definitionThunk: Thunk<Definition>) => z.ZodLazy<z.ZodEffects<z.ZodUnion<[z.ZodType<ObjectId, z.ZodTypeDef, ObjectId>, z.ZodType<ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>, z.ZodTypeDef, ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>>, ZSchemaReferenceWrapper<ZCollectionUnbranded<Definition>, Definition>]>, ZDocumentReference<Definition, undefined, z.output<ZCollectionUnbranded<Definition>>>, ObjectId | ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>> | (ZCollectionUnbranded<Definition>["_input"] & DefNameBrand<ZCollectionModelName<Definition>>)>>;
partial: <Definition_1 extends ZCollectionDefinition<any, z.AnyZodObject>, Mask extends Omit<RemoveBrand<Definition_1["schema"]>["shape"], "_id"> extends infer T ? { [key in keyof T]?: true | undefined; } : never>(definitionThunk: Thunk<Definition_1>, mask: Mask) => z.ZodLazy<z.ZodEffects<z.ZodUnion<[z.ZodType<ObjectId, z.ZodTypeDef, ObjectId>, z.ZodType<ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>, z.ZodTypeDef, ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>>, ZSchemaReferenceWrapper<z.ZodObject<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>, any, any, z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_2 extends z.ZodRawShape ? { [k_1 in keyof T_2]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_1]["_output"]; } : never> extends infer T_1 extends object ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_2 extends z.ZodRawShape ? { [k_1 in keyof T_2]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_1]["_output"]; } : never>[k]; } : never, z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_4 extends z.ZodRawShape ? { [k_3 in keyof T_4]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_3]["_input"]; } : never> extends infer T_3 extends object ? { [k_2 in keyof T_3]: z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_4 extends z.ZodRawShape ? { [k_3 in keyof T_4]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_3]["_input"]; } : never>[k_2]; } : never>, Definition_1>]>, ZDocumentReference<Definition_1, Mask, z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_2 extends z.ZodRawShape ? { [k_1 in keyof T_2]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_1]["_output"]; } : never> extends infer T_1 extends object ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_2 extends z.ZodRawShape ? { [k_1 in keyof T_2]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_1]["_output"]; } : never>[k]; } : never>, ObjectId | ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>> | ((z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_4 extends z.ZodRawShape ? { [k_3 in keyof T_4]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_3]["_input"]; } : never> extends infer T_3 extends object ? { [k_2 in keyof T_3]: z.objectUtil.addQuestionMarks<Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>> extends infer T_4 extends z.ZodRawShape ? { [k_3 in keyof T_4]: Pick<ZCollectionUnbranded<Definition_1>["shape"], "_id" | Extract<keyof ZCollectionUnbranded<Definition_1>["shape"], keyof Mask>>[k_3]["_input"]; } : never>[k_2]; } : never) & DefNameBrand<ZCollectionModelName<Definition_1>>)>>;
ref: <Definition_2 extends ZCollectionDefinition<any, z.ZodType<any, z.ZodTypeDef, any>>>(definitionThunk: Thunk<Definition_2>) => z.ZodLazy<z.ZodEffects<z.ZodUnion<[z.ZodType<ObjectId, z.ZodTypeDef, ObjectId>, z.ZodType<ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>, z.ZodTypeDef, ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>>>, ZSchemaReferenceWrapper<z.ZodObject<{
_id: z.ZodType<ObjectId, z.ZodTypeDef, ObjectId>;
}, "strip", z.ZodTypeAny, {
full: <Definition extends ZCollectionDefinition<any, z.ZodType<any, z.ZodTypeDef, any>>>(definition: Definition) => ZSchemaReferenceWrapper<Definition, undefined, ResolveZReferences<z.output<Definition["schema"]>>>;
partial: <Definition_1 extends ZCollectionDefinition<any, z.ZodType<any, z.ZodTypeDef, any>>, Mask extends { [key in Exclude<UnionOfKeys<z.output<ZCollectionUnbranded<Definition_1>>>, "_id">]?: true | undefined; }>(definition: Definition_1, mask: Mask) => ZSchemaReferenceWrapper<Definition_1, Mask, DistributiveSelectivePick<z.output<ZCollectionUnbranded<Definition_1>>, "_id" | keyof Mask>>;
ref: <Definition_2 extends ZCollectionDefinition<any, z.ZodType<any, z.ZodTypeDef, any>>>(definition: Definition_2) => ZSchemaReferenceWrapper<Definition_2, {}, {
_id: ObjectId;
}, {
_id: ObjectId;
}>, Definition_2>]>, ZDocumentReference<Definition_2, {}, {
_id: ObjectId;
}>, ObjectId | ZDocumentReference<ZCollectionDefinition<string, z.ZodType<any, z.ZodTypeDef, any>>, Record<string, true | undefined> | undefined, Record<string, any>> | ({
_id: ObjectId;
} & DefNameBrand<ZCollectionModelName<Definition_2>>)>>;
}>;
};
export type RemoveZDefinitions<T, EmbeddedSubstitute extends Record<string, any>> = T extends ObjectId | Buffer | Date ? T : T extends Array<infer U> ? Array<RemoveZDefinitions<U, EmbeddedSubstitute>> : T extends {
[DEF_NAME_SYM]: infer DefName;
} ? (DefName extends string ? EmbeddedSubstitute[DefName] : never) | {
[K in keyof Omit<T, typeof DEF_NAME_SYM>]: RemoveZDefinitions<T[K], EmbeddedSubstitute>;
} : T extends object ? {
[K in keyof T]: RemoveZDefinitions<T[K], EmbeddedSubstitute>;
} : T;
export {};

123

dist/schema/zEmbeddedSchema.js

@@ -12,12 +12,10 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.zEmbeddedSchema = exports.ZSchemaReferenceWrapper = exports.DEF_NAME_SYM = void 0;
exports.zEmbeddedSchema = exports.ZSchemaReferenceWrapper = void 0;
const mongodb_1 = require("mongodb");
const zod_1 = require("zod");
const ZDocumentReference_1 = require("../types/ZDocumentReference");
const zObjectId_1 = require("./zObjectId");
const util_1 = require("../util");
exports.DEF_NAME_SYM = Symbol("DEF_NAME_SYM");
const zongo_1 = require("../zongo");
class ZSchemaReferenceWrapper extends zod_1.ZodType {
constructor(definition, mask, def) {
super(def);
constructor(definition, mask) {
super({});
this.definition = definition;

@@ -27,76 +25,61 @@ this.mask = mask;

_parse(input) {
const { ctx } = this._processInputParams(input);
const data = ctx.data;
return this._def.type._parse({
data,
path: ctx.path,
parent: ctx,
});
}
}
exports.ZSchemaReferenceWrapper = ZSchemaReferenceWrapper;
function schemaWrapper(schemaThunk, definitionThunk, mask) {
const maskArray = Object.keys(mask || {});
return zod_1.z.lazy(() => {
const schema = (0, util_1.resolveThunk)(schemaThunk);
const definition = (0, util_1.resolveThunk)(definitionThunk);
return zod_1.z
.union([
(0, zObjectId_1.zObjectId)(),
zod_1.z.instanceof(ZDocumentReference_1.ZDocumentReference),
new ZSchemaReferenceWrapper(definition, mask ? maskArray : undefined, {
type: schema,
typeName: zod_1.z.ZodFirstPartyTypeKind.ZodBranded,
}),
])
.transform((data) => __awaiter(this, void 0, void 0, function* () {
if (data instanceof ZDocumentReference_1.ZDocumentReference) {
return data;
return __awaiter(this, void 0, void 0, function* () {
const { ctx } = this._processInputParams(input);
if (!ctx.common.async) {
throw new Error("ZSchemaReferenceWrapper must be used with async parsing");
}
// If object is ID, then resolve reference to minimal required data
if (data instanceof mongodb_1.ObjectId) {
const { zdb } = definition;
const collection = zdb.getCollection(definition.modelName);
if (mask !== undefined) {
const projection = {};
for (const key in mask) {
if (mask[key] === true) {
projection[key] = 1;
}
const data = ctx.data;
if (this.mask !== undefined) {
const mask = this.mask;
const requiredKeys = new Set(Object.keys(mask).filter((k) => mask[k]));
if (data instanceof mongodb_1.ObjectId) {
const lazyDocument = (0, zongo_1.createZLazyDocument)(data, this.definition, undefined);
const requiredData = {};
const promises = [];
for (const key of requiredKeys) {
promises.push(lazyDocument[key].then((value) => {
requiredData[key] = value;
}));
}
const doc = yield collection.findOne(data, {
projection,
});
return new ZDocumentReference_1.ZDocumentReference(data, definition, doc, mask);
yield Promise.all(promises);
return (0, zod_1.OK)(new ZDocumentReference_1.ZDocumentReference(data, this.definition, requiredData, this.mask));
}
const doc = yield collection.findOne(data);
return new ZDocumentReference_1.ZDocumentReference(data, definition, doc, mask);
let existingData;
if (data instanceof ZDocumentReference_1.ZDocumentReference) {
existingData = data.getExisting();
}
else {
existingData = data;
}
const requiredData = {};
for (const key of requiredKeys) {
requiredData[key] = existingData[key];
}
return (0, zod_1.OK)(new ZDocumentReference_1.ZDocumentReference(data._id, this.definition, requiredData, this.mask));
}
if (data._id instanceof mongodb_1.ObjectId) {
return new ZDocumentReference_1.ZDocumentReference(data._id, definition, data, mask);
let _id;
if (data instanceof mongodb_1.ObjectId) {
_id = data;
}
throw new Error("Invalid data, must have _id");
}));
});
else {
_id = data._id;
}
const document = yield this.definition.zdb
.getCollection(this.definition.modelName)
.findOne({ _id });
return (0, zod_1.OK)(new ZDocumentReference_1.ZDocumentReference(_id, this.definition, document, this.mask));
});
}
}
exports.ZSchemaReferenceWrapper = ZSchemaReferenceWrapper;
exports.zEmbeddedSchema = {
full: (definitionThunk) => {
return schemaWrapper(() => {
const definition = (0, util_1.resolveThunk)(definitionThunk);
return definition.schema.unwrap();
}, definitionThunk);
full: (definition) => {
return new ZSchemaReferenceWrapper(definition, undefined);
},
partial: (definitionThunk, mask) => {
return schemaWrapper(() => {
const definition = (0, util_1.resolveThunk)(definitionThunk);
const unbrandedSchema = definition.schema.unwrap();
return unbrandedSchema.pick(Object.assign(mask, { _id: true }));
}, definitionThunk, mask);
partial: (definition, mask) => {
return new ZSchemaReferenceWrapper(definition, mask);
},
ref: (definitionThunk) => {
const refSchema = zod_1.z.object({
_id: (0, zObjectId_1.zObjectId)(),
});
return schemaWrapper(() => refSchema, definitionThunk);
ref: (definition) => {
return new ZSchemaReferenceWrapper(definition, {});
},
};

4

dist/schema/zPartial.d.ts

@@ -1,4 +0,2 @@

import { z } from "zod";
import { Thunk } from "../util";
import { ZPartialDefinition } from "../zongo";
export declare function zPartial<PartialDefinition extends ZPartialDefinition<any, any>>(schemaThunk: Thunk<PartialDefinition>): z.ZodLazy<PartialDefinition["schema"]>;
export declare function zPartial<PartialDefinition extends ZPartialDefinition<any, any>>(partial: PartialDefinition): PartialDefinition["schema"];

8

dist/schema/zPartial.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.zPartial = void 0;
const zod_1 = require("zod");
const util_1 = require("../util");
function zPartial(schemaThunk) {
return zod_1.z.lazy(() => {
return (0, util_1.resolveThunk)(schemaThunk).schema;
});
function zPartial(partial) {
return partial.schema;
}
exports.zPartial = zPartial;

3

dist/types/ZCollectionDefinition.d.ts

@@ -1,2 +0,2 @@

import { z } from "zod";
import { z, ZodRawShape } from "zod";
import { ResolveZReferences, ZDatabase } from "./ZDatabase";

@@ -11,2 +11,3 @@ export declare class ZCollectionDefinition<ModelName extends string, Schema extends z.ZodSchema> {

constructor(modelName: ModelName, schema: Schema);
getDocumentSchema(resolutionKeyGetter: (key: string) => Promise<unknown>): Promise<ZodRawShape>;
private validateSchema;

@@ -13,0 +14,0 @@ }

158

dist/types/ZCollectionDefinition.js
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });

@@ -22,29 +31,138 @@ exports.ZCollectionDefinition = void 0;

}
getDocumentSchema(resolutionKeyGetter) {
return __awaiter(this, void 0, void 0, function* () {
function traverseSchemaForObject(schema) {
return __awaiter(this, void 0, void 0, function* () {
if (schema instanceof zod_1.z.ZodObject) {
return schema.shape;
}
else if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
const key = schema.discriminator;
const validValues = schema.validDiscriminatorValues;
const value = yield resolutionKeyGetter(key);
if (!validValues.includes(value)) {
throw new Error("Invalid discriminator value");
}
return traverseSchemaForObject(schema.options.get(value));
}
else if (schema instanceof zod_1.z.ZodUnion) {
throw new Error("ZodUnion not supported before first object");
}
else if (schema instanceof zod_1.z.ZodIntersection) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodTuple) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodBranded ||
schema instanceof zod_1.z.ZodNullable ||
schema instanceof zod_1.z.ZodOptional) {
return traverseSchemaForObject(schema.unwrap());
}
else if (schema instanceof zod_1.z.ZodEffects) {
return traverseSchemaForObject(schema.innerType());
}
else if (schema instanceof zod_1.z.ZodLazy) {
return traverseSchemaForObject(schema.schema);
}
else if (schema instanceof zod_1.z.ZodRecord) {
throw new Error("ZodRecord not supported");
}
else if (schema instanceof zod_1.z.ZodMap) {
throw new Error("ZodMap not supported");
}
else if (schema instanceof zod_1.z.ZodAny ||
schema instanceof zod_1.z.ZodUnknown ||
schema instanceof zod_1.z.ZodNever ||
schema instanceof zod_1.z.ZodVoid ||
schema instanceof zod_1.z.ZodUndefined ||
schema instanceof zod_1.z.ZodNull ||
schema instanceof zod_1.z.ZodString ||
schema instanceof zod_1.z.ZodNumber ||
schema instanceof zod_1.z.ZodBigInt ||
schema instanceof zod_1.z.ZodBoolean ||
schema instanceof zod_1.z.ZodDate ||
schema instanceof zod_1.z.ZodFunction ||
schema instanceof zod_1.z.ZodPromise ||
schema instanceof zod_1.z.ZodLiteral ||
schema instanceof zod_1.z.ZodEnum ||
schema instanceof zod_1.z.ZodNativeEnum ||
schema instanceof zod_1.z.ZodSet ||
schema instanceof zod_1.z.ZodDefault) {
throw new Error("Must reach a ZodObject first before using other primitive types");
}
else {
throw new Error(`Unsupported schema type: ${schema}`);
}
});
}
return traverseSchemaForObject(this.schema);
});
}
validateSchema(schema) {
if (schema instanceof zod_1.ZodBranded) {
this.validateSchema(schema.unwrap());
}
if (schema instanceof zod_1.ZodObject) {
const keys = Object.keys(schema.shape);
if (!keys.includes("_id")) {
throw new Error("Schema must include _id");
function traverseSchemaForObjects(schema) {
if (schema instanceof zod_1.z.ZodObject) {
if (!("_id" in schema.shape)) {
throw new Error("First schema must have _id field");
}
return;
}
return;
}
if (schema instanceof zod_1.ZodDiscriminatedUnion) {
for (const literal of schema.options.keys()) {
this.validateSchema(schema.options.get(literal));
else if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
for (const option of schema.options.values()) {
traverseSchemaForObjects(option);
}
}
return;
}
if (schema instanceof zod_1.ZodUnion) {
for (const option of schema.options) {
this.validateSchema(option);
else if (schema instanceof zod_1.z.ZodUnion) {
throw new Error("ZodUnion not supported before first object");
}
return;
else if (schema instanceof zod_1.z.ZodIntersection) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodTuple) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodBranded ||
schema instanceof zod_1.z.ZodNullable ||
schema instanceof zod_1.z.ZodOptional) {
return traverseSchemaForObjects(schema.unwrap());
}
else if (schema instanceof zod_1.z.ZodEffects) {
return traverseSchemaForObjects(schema.innerType());
}
else if (schema instanceof zod_1.z.ZodLazy) {
return traverseSchemaForObjects(schema.schema);
}
else if (schema instanceof zod_1.z.ZodRecord) {
throw new Error("ZodRecord not supported");
}
else if (schema instanceof zod_1.z.ZodMap) {
throw new Error("ZodMap not supported");
}
else if (schema instanceof zod_1.z.ZodAny ||
schema instanceof zod_1.z.ZodUnknown ||
schema instanceof zod_1.z.ZodNever ||
schema instanceof zod_1.z.ZodVoid ||
schema instanceof zod_1.z.ZodUndefined ||
schema instanceof zod_1.z.ZodNull ||
schema instanceof zod_1.z.ZodString ||
schema instanceof zod_1.z.ZodNumber ||
schema instanceof zod_1.z.ZodBigInt ||
schema instanceof zod_1.z.ZodBoolean ||
schema instanceof zod_1.z.ZodDate ||
schema instanceof zod_1.z.ZodFunction ||
schema instanceof zod_1.z.ZodPromise ||
schema instanceof zod_1.z.ZodLiteral ||
schema instanceof zod_1.z.ZodEnum ||
schema instanceof zod_1.z.ZodNativeEnum ||
schema instanceof zod_1.z.ZodSet ||
schema instanceof zod_1.z.ZodDefault) {
throw new Error("Must reach a ZodObject first before using other primitive types");
}
else {
throw new Error(`Unsupported schema type: ${schema}`);
}
}
console.error(schema);
throw new Error("Invalid schema");
traverseSchemaForObjects(schema);
}
}
exports.ZCollectionDefinition = ZCollectionDefinition;

13

dist/types/ZDatabase.d.ts
/// <reference types="node" />
import { Collection, Db, MongoClient, ObjectId } from "mongodb";
import { BRAND, z } from "zod";
import { RemoveZDefinitions } from "../schema/zEmbeddedSchema";
import { ZCollectionBranded, ZCollectionDefinition, ZCollectionModelName, ZRawDocumentType } from "./ZCollectionDefinition";
import { ZDocumentReference } from "./ZDocumentReference";
import { ZPartialDefinition, ZPartialName, ZPartialSchema } from "./ZPartialDefinition";
type CreateDocumentParam<Definitions extends DefinitionsType, Def extends keyof Definitions> = RemoveZDefinitions<Omit<z.input<ZCollectionBranded<Definitions[Def]>>, typeof BRAND>, {
[DefName in keyof Definitions]: ObjectId | ZDocumentReference<Definitions[DefName], any, any>;
}>;
type CreatePartialParam<Definitions extends DefinitionsType, Partial extends z.ZodSchema> = RemoveZDefinitions<Omit<z.input<Partial>, typeof BRAND>, {
[DefName in keyof Definitions]: ObjectId | ZDocumentReference<Definitions[DefName], any, any>;
}>;
import { ZPartialDefinition, ZPartialName } from "./ZPartialDefinition";
type CreateDocumentParam<Definitions extends DefinitionsType, Def extends keyof Definitions> = Omit<z.input<ZCollectionBranded<Definitions[Def]>>, typeof BRAND>;
type DefinitionsType = {

@@ -51,3 +45,2 @@ [key: string]: ZCollectionDefinition<any, any>;

update<Def extends keyof Definitions>(def: Def, _id: ObjectId, data: Partial<CreateDocumentParam<Definitions, Def>> | ((current: z.output<ZCollectionBranded<Definitions[Def]>>) => Promise<CreateDocumentParam<Definitions, Def>> | CreateDocumentParam<Definitions, Def>)): Promise<z.output<ZCollectionBranded<Definitions[Def]>>>;
createPartial<Name extends keyof Partials>(name: Name, data: CreatePartialParam<Definitions, ZPartialSchema<Partials[Name]>>): RemoveZDefinitions<Omit<z.input<ZPartialSchema<Partials[Name]>>, typeof BRAND>, { [DefName in keyof Definitions]: ObjectId | ZDocumentReference<Definitions[DefName], any, any>; }>;
findOneLazy<Def extends keyof Definitions>(def: Def, id: ObjectId): import("./ZLazyDocument").ZLazyDocument<Definitions[Def]>;

@@ -60,3 +53,3 @@ getRawDocument<Input>(input: Input): Promise<ResolveZReferences<Input>>;

path: string;
mask?: string[] | undefined;
mask?: Record<string, boolean> | undefined;
}[]>>;

@@ -63,0 +56,0 @@ updateReferences<DefName extends keyof Definitions>(defName: DefName, _id: ObjectId): Promise<void>;

9

dist/types/ZDatabase.js

@@ -129,9 +129,2 @@ "use strict";

}
createPartial(name, data) {
const partial = this.partials.get(name);
if (!partial) {
throw new Error(`Partial ${String(name)} not found`);
}
return data;
}
findOneLazy(def, id) {

@@ -326,3 +319,3 @@ const definition = this.definitions.get(def);

const updateKeys = {};
for (const key of (_a = ref.mask) !== null && _a !== void 0 ? _a : Object.keys(resolvedDocument)) {
for (const key of Object.keys((_a = ref.mask) !== null && _a !== void 0 ? _a : resolvedDocument)) {
updateKeys[`${ref.path}.${key}`] = resolvedDocument[key];

@@ -329,0 +322,0 @@ }

2

dist/types/ZDocumentReference.d.ts

@@ -8,4 +8,4 @@ import { ObjectId } from "mongodb";

definition: Definition;
mask: Mask;
private existingData;
mask: Mask;
constructor(_id: ObjectId, definition: Definition, existingData: ExistingData, mask: Mask);

@@ -12,0 +12,0 @@ resolve(): ZLazyDocument<Definition>;

2

dist/types/ZDocumentReference.js

@@ -18,4 +18,4 @@ "use strict";

this.definition = definition;
this.existingData = existingData;
this.mask = mask;
this.existingData = Object.assign(Object.assign({}, existingData), { _id });
}

@@ -22,0 +22,0 @@ resolve() {

126

dist/types/ZLazyDocument.js

@@ -17,6 +17,7 @@ "use strict";

const promises = new Map();
let schemaShapePromise = null;
for (const key in existingData !== null && existingData !== void 0 ? existingData : {}) {
promises.set(key, Promise.resolve(existingData));
}
const getKey = (key) => __awaiter(this, void 0, void 0, function* () {
const getKey = (key, validate) => __awaiter(this, void 0, void 0, function* () {
if (key === "_id") {

@@ -28,12 +29,22 @@ return _id;

}
if (!schemaShapePromise && validate) {
schemaShapePromise = definition.getDocumentSchema((key) => {
return getKey(key, false);
});
}
if (promises.has(key)) {
const docSoFar = {};
for (const [_, promise] of promises) {
Object.assign(docSoFar, yield promise);
if (validate) {
const docSoFar = {};
for (const [_, promise] of promises) {
Object.assign(docSoFar, yield promise);
}
const schemaShape = yield schemaShapePromise;
const schema = zod_1.z
.strictObject(schemaShape)
.pick(Object.fromEntries(Object.keys(docSoFar).map((key) => [key, true])));
const result = yield schema.parseAsync(docSoFar);
return result[key];
}
const parsedResult = yield definition.schema.safeParseAsync(docSoFar);
if (parsedResult.success) {
return parsedResult.data[key];
}
throw new Error("Parsing failed");
const result = yield promises.get(key);
return result[key];
}

@@ -43,3 +54,3 @@ if (pendingRead) {

yield pendingRead;
return getKey(key);
return getKey(key, validate);
}

@@ -66,99 +77,8 @@ pendingRead = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {

}));
return getKey(key);
return getKey(key, validate);
});
function traverseSchemaForObject(schema) {
return __awaiter(this, void 0, void 0, function* () {
if (schema instanceof zod_1.z.ZodObject) {
return schema.shape;
}
else if (schema instanceof zod_1.z.ZodUnion) {
throw new Error("ZodUnion not supported before first object");
}
else if (schema instanceof zod_1.z.ZodIntersection) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodDiscriminatedUnion) {
const key = schema.discriminator;
const validValues = schema.validDiscriminatorValues;
const value = yield getKey(key);
if (!validValues.includes(value)) {
throw new Error("Invalid discriminator value");
}
return traverseSchemaForObject(schema.options.get(value));
}
else if (schema instanceof zod_1.z.ZodTuple) {
throw new Error("ZodIntersection not supported before first object");
}
else if (schema instanceof zod_1.z.ZodBranded) {
return traverseSchemaForObject(schema.unwrap());
}
else if (schema instanceof zod_1.z.ZodNullable) {
return traverseSchemaForObject(schema.unwrap());
}
else if (schema instanceof zod_1.z.ZodEffects) {
return traverseSchemaForObject(schema.innerType());
}
else if (schema instanceof zod_1.z.ZodSet) {
return traverseSchemaForObject(schema._def.valueType);
}
else if (schema instanceof zod_1.z.ZodOptional) {
return traverseSchemaForObject(schema.unwrap());
}
else if (schema instanceof zod_1.z.ZodLazy) {
return traverseSchemaForObject(schema.schema);
}
else if (schema instanceof zod_1.z.ZodDefault) {
return traverseSchemaForObject(schema.removeDefault());
}
else if (schema instanceof zod_1.z.ZodRecord) {
throw new Error("ZodRecord not supported");
}
else if (schema instanceof zod_1.z.ZodMap) {
throw new Error("ZodMap not supported");
}
else if (schema instanceof zod_1.z.ZodAny ||
schema instanceof zod_1.z.ZodUnknown ||
schema instanceof zod_1.z.ZodNever ||
schema instanceof zod_1.z.ZodVoid ||
schema instanceof zod_1.z.ZodUndefined ||
schema instanceof zod_1.z.ZodNull ||
schema instanceof zod_1.z.ZodString ||
schema instanceof zod_1.z.ZodNumber ||
schema instanceof zod_1.z.ZodBigInt ||
schema instanceof zod_1.z.ZodBoolean ||
schema instanceof zod_1.z.ZodDate ||
schema instanceof zod_1.z.ZodFunction ||
schema instanceof zod_1.z.ZodPromise ||
schema instanceof zod_1.z.ZodLiteral ||
schema instanceof zod_1.z.ZodEnum ||
schema instanceof zod_1.z.ZodNativeEnum) {
throw new Error("Unsupported schema type");
}
else {
throw new Error(`Unsupported schema type: ${schema}`);
}
});
}
let schemaShape = null;
function getSchemaShape() {
if (!schemaShape) {
schemaShape = traverseSchemaForObject(definition.schema);
}
return schemaShape;
}
const proxy = new Proxy(existingData !== null && existingData !== void 0 ? existingData : {}, {
get(_target, prop) {
return __awaiter(this, void 0, void 0, function* () {
const schemaShape = yield getSchemaShape();
if (!(prop in schemaShape)) {
return undefined;
}
return zod_1.z
.strictObject({
[prop]: schemaShape[prop],
})
.parseAsync({
[prop]: yield getKey(prop),
})
.then((res) => res[prop]);
return getKey(prop, true);
});

@@ -165,0 +85,0 @@ },

2

package.json
{
"name": "zongo",
"version": "0.0.18",
"version": "0.0.19",
"main": "dist/index.js",

@@ -5,0 +5,0 @@ "types": "dist/index.d.ts",

dist/types/ZCollection.d.ts
dist/types/ZCollection.js
dist/util.d.ts
dist/util.js