@rpcbase/db 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,649 @@
+import { Schema, isValidObjectId, Types, SchemaTypes } from "mongoose";
+import { z, ZodMap, ZodRecord, ZodAny, ZodUnion, ZodNullable, ZodOptional, ZodDefault, ZodDate, ZodEnum, ZodBoolean, ZodArray, ZodObject, ZodNumber, ZodString } from "zod";
+export * from "zod";
+import { z as z2 } from "zod";
+const ZUser = z.object({
+  email: z.string().email().optional(),
+  password: z.string(),
+  name: z.string().optional(),
+  phone: z.string().optional(),
+  tenants: z.array(z.string()),
+  email_verification_code: z.string().length(6).optional(),
+  email_verification_expires_at: z.date().optional()
+});
+const UserSchema = new Schema({
+  email: { type: String, unique: true, sparse: true },
+  phone: { type: String, unique: true, sparse: true },
+  password: { type: String, required: true },
+  name: String,
+  tenants: { type: [String], index: true, required: true },
+  email_verification_code: { type: String, required: false },
+  email_verification_expires_at: { type: Date, required: false }
+});
+const ZTenant = z.object({
+  tenant_id: z.string(),
+  parent_tenant_id: z.string().optional(),
+  name: z.string().optional()
+});
+const TenantSchema = new Schema({
+  tenant_id: { type: String, required: true, unique: true, index: true },
+  parent_tenant_id: { type: String },
+  name: { type: String }
+});
+const zmAssert$4 = {
+  string(f) {
+    return f.constructor.name === "ZodString";
+  },
+  number(f) {
+    return f.constructor.name === "ZodNumber";
+  },
+  object(f) {
+    return f.constructor.name === "ZodObject";
+  },
+  array(f) {
+    return f.constructor.name === "ZodArray";
+  },
+  boolean(f) {
+    return f.constructor.name === "ZodBoolean";
+  },
+  enumerable(f) {
+    return f.constructor.name === "ZodEnum";
+  },
+  date(f) {
+    return f.constructor.name === "ZodDate";
+  },
+  def(f) {
+    return f.constructor.name === "ZodDefault";
+  },
+  optional(f) {
+    return f.constructor.name === "ZodOptional";
+  },
+  nullable(f) {
+    return f.constructor.name === "ZodNullable";
+  },
+  union(f) {
+    return f.constructor.name === "ZodUnion";
+  },
+  any(f) {
+    return f.constructor.name === "ZodAny";
+  },
+  mapOrRecord(f) {
+    return f.constructor.name === "ZodMap" || f.constructor.name === "ZodRecord";
+  }
+};
+const zmAssertIds = {
+  objectId(f) {
+    return "__zm_type" in f && f.__zm_type === "ObjectId";
+  },
+  uuid(f) {
+    return "__zm_type" in f && f.__zm_type === "UUID";
+  }
+};
+const zmAssert$3 = {
+  string(f) {
+    return f instanceof ZodString;
+  },
+  number(f) {
+    return f instanceof ZodNumber;
+  },
+  object(f) {
+    return f instanceof ZodObject;
+  },
+  array(f) {
+    return f instanceof ZodArray;
+  },
+  boolean(f) {
+    return f instanceof ZodBoolean;
+  },
+  enumerable(f) {
+    return f instanceof ZodEnum;
+  },
+  date(f) {
+    return f instanceof ZodDate;
+  },
+  def(f) {
+    return f instanceof ZodDefault;
+  },
+  optional(f) {
+    return f instanceof ZodOptional;
+  },
+  nullable(f) {
+    return f instanceof ZodNullable;
+  },
+  union(f) {
+    return f instanceof ZodUnion;
+  },
+  any(f) {
+    return f instanceof ZodAny;
+  },
+  mapOrRecord(f) {
+    return f instanceof ZodMap || f instanceof ZodRecord;
+  }
+};
+const zmAssert$2 = {
+  string(f) {
+    return "__zm_type" in f && f.__zm_type === "String";
+  },
+  number(f) {
+    return "__zm_type" in f && f.__zm_type === "Number";
+  },
+  object(f) {
+    return "__zm_type" in f && f.__zm_type === "Object";
+  },
+  array(f) {
+    return "__zm_type" in f && f.__zm_type === "Array";
+  },
+  boolean(f) {
+    return "__zm_type" in f && f.__zm_type === "Boolean";
+  },
+  enumerable(f) {
+    return "__zm_type" in f && f.__zm_type === "Enum";
+  },
+  date(f) {
+    return "__zm_type" in f && f.__zm_type === "Date";
+  },
+  def(f) {
+    return "__zm_type" in f && f.__zm_type === "Default";
+  },
+  optional(f) {
+    return "__zm_type" in f && f.__zm_type === "Optional";
+  },
+  nullable(f) {
+    return "__zm_type" in f && f.__zm_type === "Nullable";
+  },
+  union(f) {
+    return "__zm_type" in f && f.__zm_type === "Union";
+  },
+  any(f) {
+    return "__zm_type" in f && f.__zm_type === "Any";
+  },
+  mapOrRecord(f) {
+    return "__zm_type" in f && (f.__zm_type === "Map" || f.__zm_type === "Record");
+  }
+};
+const assertions = [zmAssert$4, zmAssert$3, zmAssert$2];
+const zmAssert = Object.keys(zmAssert$4).map((key) => key).reduce((acc, key) => {
+  acc[key] = (f) => {
+    return assertions.some((assertion) => assertion[key](f));
+  };
+  return acc;
+}, {});
+const zmAssert$1 = {
+  ...zmAssert,
+  ...zmAssertIds
+};
+let zod_extended = false;
+const isSchemaCandidate = (value) => {
+  return Boolean(value && typeof value === "object" && "_def" in value);
+};
+const resolveSchemaAndFlag = (self, args, defaultFlag = true) => {
+  let schema = isSchemaCandidate(self) ? self : void 0;
+  let flag;
+  if (args.length > 0) {
+    const [firstArg, secondArg] = args;
+    if (typeof firstArg === "boolean") flag = firstArg;
+    if (typeof secondArg === "boolean") flag = secondArg;
+    if (!schema && isSchemaCandidate(firstArg)) {
+      schema = firstArg;
+      if (typeof secondArg === "boolean") flag = secondArg;
+    }
+  }
+  if (!schema) return { schema: void 0, flag: defaultFlag };
+  if (typeof flag !== "boolean") flag = defaultFlag;
+  return { schema, flag };
+};
+const resolveSchemaAndValue = (self, args) => {
+  let schema = isSchemaCandidate(self) ? self : void 0;
+  let value = args[0];
+  if (!schema && isSchemaCandidate(value)) {
+    schema = value;
+    value = args.length > 1 ? args[1] : void 0;
+  }
+  return { schema, value };
+};
+function extendZod(z_0) {
+  if (zod_extended) return;
+  zod_extended = true;
+  const UNIQUE_SUPPORT_LIST = [z_0.ZodString, z_0.ZodNumber, z_0.ZodDate];
+  for (const type of UNIQUE_SUPPORT_LIST) {
+    const proto = type?.prototype;
+    if (!proto) continue;
+    proto.unique = function unique(...args) {
+      const { schema, flag } = resolveSchemaAndFlag(this, args);
+      if (!schema) return this;
+      schema.__zm_unique = flag;
+      if (schema._def && typeof schema._def === "object") {
+        schema._def.__zm_unique = flag;
+      }
+      return schema;
+    };
+    proto.sparse = function sparse(...args) {
+      const { schema, flag } = resolveSchemaAndFlag(this, args);
+      if (!schema) return this;
+      schema.__zm_sparse = flag;
+      if (schema._def && typeof schema._def === "object") {
+        schema._def.__zm_sparse = flag;
+      }
+      return schema;
+    };
+  }
+  const TypesMap = {
+    String: z_0.ZodString,
+    Number: z_0.ZodNumber,
+    Object: z_0.ZodObject,
+    Array: z_0.ZodArray,
+    Boolean: z_0.ZodBoolean,
+    Enum: z_0.ZodEnum,
+    Date: z_0.ZodDate,
+    Default: z_0.ZodDefault,
+    Optional: z_0.ZodOptional,
+    Nullable: z_0.ZodNullable,
+    Union: z_0.ZodUnion,
+    Any: z_0.ZodAny,
+    Map: z_0.ZodMap,
+    Record: z_0.ZodRecord,
+    Pipe: z_0.ZodPipe
+  };
+  for (const [key, value] of Object.entries(TypesMap)) {
+    if (value?.prototype) {
+      value.prototype.__zm_type = key;
+    }
+  }
+}
+const createId = () => {
+  return z.string().refine((v) => isValidObjectId(v), { error: "Invalid ObjectId" }).or(z.instanceof(Types.ObjectId));
+};
+const zId = (ref) => {
+  const output = createId();
+  const schema = output;
+  schema.__zm_type = "ObjectId";
+  schema.__zm_ref = ref;
+  schema.ref = function ref2(...args) {
+    const { schema: target, value } = resolveSchemaAndValue(this, args);
+    if (!target || typeof value !== "string") return target ?? this;
+    target.__zm_ref = value;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_ref = value;
+    }
+    return target;
+  };
+  schema.refPath = function refPath(...args) {
+    const { schema: target, value } = resolveSchemaAndValue(this, args);
+    if (!target || typeof value !== "string") return target ?? this;
+    target.__zm_refPath = value;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_refPath = value;
+    }
+    return target;
+  };
+  schema.unique = function unique(...args) {
+    const { schema: target, flag } = resolveSchemaAndFlag(this, args);
+    if (!target) return this;
+    target.__zm_unique = flag;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_unique = flag;
+    }
+    return target;
+  };
+  schema.sparse = function sparse(...args) {
+    const { schema: target, flag } = resolveSchemaAndFlag(this, args);
+    if (!target) return this;
+    target.__zm_sparse = flag;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_sparse = flag;
+    }
+    return target;
+  };
+  return output;
+};
+const createUUID = () => {
+  return z.uuid({ error: "Invalid UUID" }).or(z.instanceof(Types.UUID));
+};
+const zUUID = (ref) => {
+  const output = createUUID();
+  const schema = output;
+  schema.__zm_type = "UUID";
+  schema.__zm_ref = ref;
+  schema.ref = function ref2(...args) {
+    const { schema: target, value } = resolveSchemaAndValue(this, args);
+    if (!target || typeof value !== "string") return target ?? this;
+    target.__zm_ref = value;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_ref = value;
+    }
+    return target;
+  };
+  schema.refPath = function refPath(...args) {
+    const { schema: target, value } = resolveSchemaAndValue(this, args);
+    if (!target || typeof value !== "string") return target ?? this;
+    target.__zm_refPath = value;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_refPath = value;
+    }
+    return target;
+  };
+  schema.unique = function unique(...args) {
+    const { schema: target, flag } = resolveSchemaAndFlag(this, args);
+    if (!target) return this;
+    target.__zm_unique = flag;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_unique = flag;
+    }
+    return target;
+  };
+  schema.sparse = function sparse(...args) {
+    const { schema: target, flag } = resolveSchemaAndFlag(this, args);
+    if (!target) return this;
+    target.__zm_sparse = flag;
+    if (target._def && typeof target._def === "object") {
+      target._def.__zm_sparse = flag;
+    }
+    return target;
+  };
+  return output;
+};
+function zodSchema(schema, options) {
+  const definition = parseObject(schema);
+  return new Schema(definition, options);
+}
+function zodSchemaRaw(schema) {
+  return parseObject(schema);
+}
+function parseObject(obj) {
+  const object = {};
+  for (const [key, rawField] of Object.entries(obj.shape)) {
+    const field = rawField;
+    if (zmAssert$1.object(field)) {
+      object[key] = parseObject(field);
+    } else {
+      const f = parseField(field);
+      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+      object[key] = f;
+    }
+  }
+  return object;
+}
+function extractCustomValidation(field) {
+  const checks = field._def?.checks;
+  if (!Array.isArray(checks)) return void 0;
+  for (const check of checks) {
+    if (!check || typeof check !== "object") continue;
+    if (check.__zm_validation) {
+      return check.__zm_validation;
+    }
+    const def = check.def;
+    if (!def || def.type !== "custom" || typeof def.fn !== "function") continue;
+    const validator = (value) => {
+      try {
+        const result = def.fn(value, {
+          ctx: {
+            addIssue() {
+              return void 0;
+            }
+          },
+          input: value,
+          parsedType: typeof value
+        });
+        return result !== false;
+      } catch {
+        return false;
+      }
+    };
+    let message;
+    if (typeof def.error === "function") {
+      try {
+        const computed = def.error({
+          ctx: {
+            addIssue() {
+              return void 0;
+            }
+          },
+          input: void 0,
+          parsedType: "unknown"
+        });
+        if (typeof computed === "string") {
+          message = computed;
+        }
+      } catch {
+      }
+    }
+    const validation = {
+      validator,
+      message
+    };
+    check.__zm_validation = validation;
+    return validation;
+  }
+  return void 0;
+}
+function parseField(field, required = true, def, refinement) {
+  if (!field) return null;
+  const customRefinement = extractCustomValidation(field);
+  const directRefinement = field.__zm_validation ?? field._def?.__zm_validation ?? customRefinement;
+  const currentRefinement = refinement ?? directRefinement;
+  if (zmAssert$1.objectId(field)) {
+    const ref = field.__zm_ref;
+    const refPath = field.__zm_refPath;
+    const unique = field.__zm_unique ?? (field._def?.__zm_unique ?? false);
+    const sparse = field.__zm_sparse ?? (field._def?.__zm_sparse ?? false);
+    return parseObjectId(required, ref, unique, refPath, sparse);
+  }
+  if (zmAssert$1.uuid(field)) {
+    const ref = field.__zm_ref;
+    const refPath = field.__zm_refPath;
+    const unique = field.__zm_unique ?? (field._def?.__zm_unique ?? false);
+    const sparse = field.__zm_sparse ?? (field._def?.__zm_sparse ?? false);
+    return parseUUID(required, ref, unique, refPath, sparse);
+  }
+  if (zmAssert$1.object(field)) {
+    return parseObject(field);
+  }
+  if (zmAssert$1.number(field)) {
+    const isUnique = field.__zm_unique ?? field._def?.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? field._def?.__zm_sparse ?? false;
+    return parseNumber(
+      field,
+      required,
+      def,
+      isUnique,
+      currentRefinement,
+      isSparse
+    );
+  }
+  if (zmAssert$1.string(field)) {
+    const isUnique = field.__zm_unique ?? field._def?.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? field._def?.__zm_sparse ?? false;
+    return parseString(
+      field,
+      required,
+      def,
+      isUnique,
+      currentRefinement,
+      isSparse
+    );
+  }
+  if (zmAssert$1.enumerable(field)) {
+    const enumValues = Array.isArray(field.options) ? field.options : Object.values(field.enum ?? {});
+    return parseEnum(enumValues, required, def);
+  }
+  if (zmAssert$1.boolean(field)) {
+    return parseBoolean(required, def);
+  }
+  if (zmAssert$1.date(field)) {
+    const isUnique = field.__zm_unique ?? field._def?.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? field._def?.__zm_sparse ?? false;
+    return parseDate(
+      required,
+      def,
+      currentRefinement,
+      isUnique,
+      isSparse
+    );
+  }
+  if (zmAssert$1.array(field)) {
+    return parseArray(
+      required,
+      field.element,
+      def
+    );
+  }
+  if (zmAssert$1.def(field)) {
+    const defaultValue = typeof field._def.defaultValue === "function" ? field._def.defaultValue() : field._def.defaultValue;
+    return parseField(
+      field._def.innerType,
+      required,
+      defaultValue,
+      currentRefinement
+    );
+  }
+  if (zmAssert$1.optional(field)) {
+    return parseField(field._def.innerType, false, void 0, currentRefinement);
+  }
+  if (zmAssert$1.nullable(field)) {
+    return parseField(
+      field._def.innerType,
+      false,
+      def || null,
+      currentRefinement
+    );
+  }
+  if (zmAssert$1.union(field)) {
+    return parseField(field._def.options[0], required, def, currentRefinement);
+  }
+  if (zmAssert$1.any(field)) {
+    return parseMixed(required, def);
+  }
+  if (zmAssert$1.mapOrRecord(field)) {
+    const mapValueType = field.valueType ?? field.valueSchema;
+    const mapKeyType = field.keyType ?? field.keySchema;
+    if (!mapKeyType) {
+      throw new Error("Unsupported map key type: undefined");
+    }
+    return parseMap(
+      required,
+      mapValueType,
+      def
+    );
+  }
+  return null;
+}
+function parseNumber(field, required = true, def, unique = false, validate, sparse = false) {
+  const output = {
+    type: Number,
+    default: def,
+    min: field.minValue ?? void 0,
+    max: field.maxValue ?? void 0,
+    required,
+    unique,
+    sparse
+  };
+  if (validate) output.validate = validate;
+  return output;
+}
+function parseString(field, required = true, def, unique = false, validate, sparse = false) {
+  const output = {
+    type: String,
+    default: def,
+    required,
+    minLength: field.minLength ?? void 0,
+    maxLength: field.maxLength ?? void 0,
+    unique,
+    sparse
+  };
+  if (validate) output.validate = validate;
+  return output;
+}
+function parseEnum(values, required = true, def) {
+  return {
+    type: String,
+    unique: false,
+    sparse: false,
+    default: def,
+    enum: values,
+    required
+  };
+}
+function parseBoolean(required = true, def) {
+  return {
+    type: Boolean,
+    default: def,
+    required
+  };
+}
+function parseDate(required = true, def, validate, unique = false, sparse = false) {
+  const output = {
+    type: Date,
+    default: def,
+    required,
+    unique,
+    sparse
+  };
+  if (validate) output.validate = validate;
+  return output;
+}
+function parseObjectId(required = true, ref, unique = false, refPath, sparse = false) {
+  const output = {
+    type: SchemaTypes.ObjectId,
+    required,
+    unique,
+    sparse
+  };
+  if (ref) output.ref = ref;
+  if (refPath) output.refPath = refPath;
+  return output;
+}
+function parseArray(required = true, element, def) {
+  const innerType = parseField(element);
+  if (!innerType) throw new Error("Unsupported array type");
+  return {
+    type: [innerType],
+    default: def,
+    required
+  };
+}
+function parseMap(required = true, valueType, def) {
+  if (!valueType) {
+    throw new Error("Unsupported map value type: undefined");
+  }
+  const pointer = parseField(valueType);
+  if (!pointer) {
+    const typeName = valueType?.constructor?.name ?? "unknown";
+    throw new Error(`Unsupported map value type (${typeName})`);
+  }
+  return {
+    type: Map,
+    of: pointer,
+    default: def,
+    required
+  };
+}
+function parseUUID(required = true, ref, unique = false, refPath, sparse = false) {
+  const output = {
+    type: SchemaTypes.UUID,
+    required,
+    unique,
+    sparse
+  };
+  if (ref) output.ref = ref;
+  if (refPath) output.refPath = refPath;
+  return output;
+}
+function parseMixed(required = true, def) {
+  return {
+    type: SchemaTypes.Mixed,
+    default: def,
+    required
+  };
+}
+export {
+  TenantSchema,
+  UserSchema,
+  ZTenant,
+  ZUser,
+  extendZod,
+  z2 as z,
+  zId,
+  zUUID,
+  zodSchema,
+  zodSchemaRaw
+};

package/dist/models/Tenant.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from '../../../vite/node_modules/mongoose';
+import { z } from '../../../vite/node_modules/zod';
+export declare const ZTenant: z.ZodObject<{
+    tenant_id: z.ZodString;
+    parent_tenant_id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ITenant = z.infer<typeof ZTenant>;
+export declare const TenantSchema: Schema;
+//# sourceMappingURL=Tenant.d.ts.map

package/dist/models/Tenant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tenant.d.ts","sourceRoot":"","sources":["../../src/models/Tenant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,OAAO;;;;iBAIlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAE9C,eAAO,MAAM,YAAY,EAAE,MAIzB,CAAA"}

package/dist/models/User.d.ts

@@ -0,0 +1,14 @@
+import { Schema } from '../../../vite/node_modules/mongoose';
+import { z } from '../../../vite/node_modules/zod';
+export declare const ZUser: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    password: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+    tenants: z.ZodArray<z.ZodString>;
+    email_verification_code: z.ZodOptional<z.ZodString>;
+    email_verification_expires_at: z.ZodOptional<z.ZodDate>;
+}, z.core.$strip>;
+export type IUser = z.infer<typeof ZUser>;
+export declare const UserSchema: Schema;
+//# sourceMappingURL=User.d.ts.map

package/dist/models/User.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"User.d.ts","sourceRoot":"","sources":["../../src/models/User.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,KAAK;;;;;;;;iBAQhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAE1C,eAAO,MAAM,UAAU,EAAE,MAQvB,CAAA"}

package/dist/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './User';
+export * from './Tenant';
+//# sourceMappingURL=index.d.ts.map

package/dist/models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA"}

package/dist/schema/assertions/assertions.d.ts

@@ -0,0 +1,20 @@
+import { ZodType } from '../../../../vite/node_modules/zod';
+declare const _default: {
+    objectId(f: ZodType<any>): f is ZodType<string>;
+    uuid(f: ZodType<any>): f is ZodType<string>;
+    string(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodString;
+    number(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodNumber;
+    object(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodObject<any>;
+    array(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodArray<any>;
+    boolean(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodBoolean;
+    enumerable(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodEnum<any>;
+    date(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodDate;
+    def(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodDefault<any>;
+    optional(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodOptional<any>;
+    nullable(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodNullable<any>;
+    union(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodUnion<any>;
+    any(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodAny;
+    mapOrRecord(f: ZodType<any>): f is import('../../../../vite/node_modules/zod').ZodMap<any> | import('../../../../vite/node_modules/zod').ZodRecord<any>;
+};
+export default _default;
+//# sourceMappingURL=assertions.d.ts.map

package/dist/schema/assertions/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;;;;;;;;;;;;;;;;;;AAoBlC,wBAGC"}

package/dist/schema/assertions/constructor.d.ts

@@ -0,0 +1,10 @@
+import { IAsserts } from './types';
+/**
+ * Constructor assertions (CommonJS)
+ * @internal
+ *
+ * Asserts if a Zod type is a specific type
+ * by checking the constructor name of it's prototype.
+ */
+export declare const zmAssert: IAsserts;
+//# sourceMappingURL=constructor.d.ts.map

package/dist/schema/assertions/constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/constructor.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,QAoDtB,CAAA"}

package/dist/schema/assertions/custom.d.ts

@@ -0,0 +1,6 @@
+import { ZodType } from '../../../../vite/node_modules/zod';
+export declare const zmAssertIds: {
+    objectId(f: ZodType<any>): f is ZodType<string>;
+    uuid(f: ZodType<any>): f is ZodType<string>;
+};
+//# sourceMappingURL=custom.d.ts.map

package/dist/schema/assertions/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/custom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAGlC,eAAO,MAAM,WAAW;gBACV,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC;YAIvC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC;CAG5C,CAAA"}

package/dist/schema/assertions/instanceOf.d.ts

@@ -0,0 +1,10 @@
+import { IAsserts } from './types';
+/**
+ * Instance assertions (ESM)
+ * @internal
+ *
+ * Asserts if a Zod type is a specific type
+ * by checking the instance of it's prototype.
+ */
+export declare const zmAssert: IAsserts;
+//# sourceMappingURL=instanceOf.d.ts.map

package/dist/schema/assertions/instanceOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceOf.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/instanceOf.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,QAoDtB,CAAA"}

package/dist/schema/assertions/staticNames.d.ts

@@ -0,0 +1,10 @@
+import { IAsserts } from './types';
+/**
+ * Static names assertions (Bundlers)
+ * @internal
+ *
+ * Asserts if a Zod type is a specific type
+ * by checking the `__zm_type` property of it's prototype.
+ */
+export declare const zmAssert: IAsserts;
+//# sourceMappingURL=staticNames.d.ts.map

package/dist/schema/assertions/staticNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticNames.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/staticNames.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,EAAE,QAoDtB,CAAA"}

package/dist/schema/assertions/types.d.ts

@@ -0,0 +1,17 @@
+import { ZodAny, ZodArray, ZodBoolean, ZodDate, ZodDefault, ZodEnum, ZodMap, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRecord, ZodString, ZodType, ZodUnion } from '../../../../vite/node_modules/zod';
+export interface IAsserts {
+    string(f: ZodType<any>): f is ZodString;
+    number(f: ZodType<any>): f is ZodNumber;
+    object(f: ZodType<any>): f is ZodObject<any>;
+    array(f: ZodType<any>): f is ZodArray<any>;
+    boolean(f: ZodType<any>): f is ZodBoolean;
+    enumerable(f: ZodType<any>): f is ZodEnum<any>;
+    date(f: ZodType<any>): f is ZodDate;
+    def(f: ZodType<any>): f is ZodDefault<any>;
+    optional(f: ZodType<any>): f is ZodOptional<any>;
+    nullable(f: ZodType<any>): f is ZodNullable<any>;
+    union(f: ZodType<any>): f is ZodUnion<any>;
+    any(f: ZodType<any>): f is ZodAny;
+    mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/schema/assertions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/assertions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAW,EACX,SAAS,EACT,SAAS,EACT,WAAW,EACX,SAAS,EACT,SAAS,EACT,OAAO,EACP,QAAQ,EACT,MAAM,KAAK,CAAA;AAGZ,MAAM,WAAW,QAAQ;IACvB,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,SAAS,CAAA;IACvC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,SAAS,CAAA;IACvC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,CAAA;IAC5C,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAA;IAC1C,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,UAAU,CAAA;IACzC,UAAU,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,CAAA;IAC9C,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAA;IACnC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,CAAA;IAC1C,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,CAAA;IAChD,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,CAAA;IAChD,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAA;IAC1C,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,MAAM,CAAA;IACjC,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;CAChE"}

package/dist/schema/extension.d.ts

@@ -0,0 +1,66 @@
+import { Types } from '../../../vite/node_modules/mongoose';
+import { z } from '../../../vite/node_modules/zod';
+declare module '../../../vite/node_modules/zod' {
+    interface ZodString {
+        unique: (arg?: boolean) => ZodString;
+        sparse: (arg?: boolean) => ZodString;
+        __zm_unique: boolean;
+        __zm_sparse: boolean;
+    }
+    interface ZodNumber {
+        unique: (arg?: boolean) => ZodNumber;
+        sparse: (arg?: boolean) => ZodNumber;
+        __zm_unique: boolean;
+        __zm_sparse: boolean;
+    }
+    interface ZodDate {
+        unique: (arg?: boolean) => ZodDate;
+        sparse: (arg?: boolean) => ZodDate;
+        __zm_unique: boolean;
+        __zm_sparse: boolean;
+    }
+}
+/**
+ * Extends the Zod library with additional functionality.
+ *
+ * This function modifies the Zod library to add custom validation and uniqueness checks.
+ * It ensures that the extension is only applied once.
+ *
+ * @param z_0 - The Zod library to extend.
+ *
+ * @remarks
+ * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.
+ * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.
+ * - Overrides `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod"
+ * import { extendZod } from "./extension"
+ *
+ * extendZod(z)
+ *
+ * const schema = z.object({
+ *   name: z.string().unique()
+ * })
+ * ```
+ */
+export declare function extendZod(z_0: typeof z): void;
+export type TzmId = ReturnType<typeof createId> & {
+    unique: (arg?: boolean) => TzmId;
+    sparse: (arg?: boolean) => TzmId;
+    ref: (arg: string) => TzmId;
+    refPath: (arg: string) => TzmId;
+};
+declare const createId: () => z.ZodUnion<[z.ZodString, z.ZodCustom<Types.ObjectId, Types.ObjectId>]>;
+export declare const zId: (ref?: string) => TzmId;
+export type TzmUUID = ReturnType<typeof createUUID> & {
+    unique: (arg?: boolean) => TzmUUID;
+    sparse: (arg?: boolean) => TzmUUID;
+    ref: (arg: string) => TzmUUID;
+    refPath: (arg: string) => TzmUUID;
+};
+declare const createUUID: () => z.ZodUnion<[z.ZodUUID, z.ZodCustom<Types.UUID, Types.UUID>]>;
+export declare const zUUID: (ref?: string) => TzmUUID;
+export {};
+//# sourceMappingURL=extension.d.ts.map

package/dist/schema/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../src/schema/extension.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAmB,MAAM,UAAU,CAAA;AACjD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,QAAQ,KAAK,CAAC;IACnB,UAAU,SAAS;QACjB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,SAAS,CAAA;QACpC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,SAAS,CAAA;QACpC,WAAW,EAAE,OAAO,CAAA;QACpB,WAAW,EAAE,OAAO,CAAA;KACrB;IAED,UAAU,SAAS;QACjB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,SAAS,CAAA;QACpC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,SAAS,CAAA;QACpC,WAAW,EAAE,OAAO,CAAA;QACpB,WAAW,EAAE,OAAO,CAAA;KACrB;IAED,UAAU,OAAO;QACf,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;QAClC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;QAClC,WAAW,EAAE,OAAO,CAAA;QACpB,WAAW,EAAE,OAAO,CAAA;KACrB;CAEF;AA+CD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,CAAC,QA2DtC;AAED,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,GAAG;IAChD,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,KAAK,CAAA;IAChC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,KAAK,CAAA;IAChC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAA;IAC3B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAA;CAChC,CAAA;AAED,QAAA,MAAM,QAAQ,8EAKb,CAAA;AAED,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,KAAG,KAoDlC,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG;IACpD,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAClC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAClC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;IAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAClC,CAAA;AAED,QAAA,MAAM,UAAU,oEAEf,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,KAAG,OAoDpC,CAAA"}

package/dist/schema/index.d.ts

@@ -0,0 +1,73 @@
+import { Schema, SchemaOptions } from '../../../vite/node_modules/mongoose';
+import { ZodObject, ZodRawShape, z } from '../../../vite/node_modules/zod';
+import type * as zm from "./mongoose.types";
+export * from './extension';
+export * from '../../../vite/node_modules/zod';
+export { z };
+/**
+ * Converts a Zod schema to a Mongoose schema
+ * @param schema zod schema to parse
+ * @returns mongoose schema
+ *
+ * @example
+ * import { extendZod, zodSchema } from "@zodyac/zod-mongoose"
+ * import { model } from "mongoose"
+ * import { z } from "zod"
+ *
+ * extendZod(z)
+ *
+ * const zUser = z.object({
+ *   name: z.string().min(3).max(255),
+ *   age: z.number().min(18).max(100),
+ *   active: z.boolean().default(false),
+ *   access: z.enum(["admin", "user"]).default("user"),
+ *   companyId: zId("Company"),
+ *   address: z.object({
+ *     street: z.string(),
+ *     city: z.string(),
+ *     state: z.enum(["CA", "NY", "TX"]),
+ *   }),
+ *   tags: z.array(z.string()),
+ *   createdAt: z.date(),
+ *   updatedAt: z.date(),
+ * })
+ *
+ * const schema = zodSchema(zDoc)
+ * const userModel = model("User", schema)
+ */
+export declare function zodSchema<T extends ZodRawShape>(schema: ZodObject<T>, options?: SchemaOptions<any>): Schema<z.infer<typeof schema>>;
+/**
+ * Converts a Zod schema to a raw Mongoose schema object
+ * @param schema zod schema to parse
+ * @returns mongoose schema
+ *
+ * @example
+ * import { extendZod, zodSchemaRaw } from "@zodyac/zod-mongoose"
+ * import { model, Schema } from "mongoose"
+ * import { z } from "zod"
+ *
+ * extendZod(z)
+ *
+ * const zUser = z.object({
+ *   name: z.string().min(3).max(255),
+ *   age: z.number().min(18).max(100),
+ *   active: z.boolean().default(false),
+ *   access: z.enum(["admin", "user"]).default("user"),
+ *   companyId: zId("Company"),
+ *   address: z.object({
+ *     street: z.string(),
+ *     city: z.string(),
+ *     state: z.enum(["CA", "NY", "TX"]),
+ *   }),
+ *   tags: z.array(z.string()),
+ *   createdAt: z.date(),
+ *   updatedAt: z.date(),
+ * })
+ *
+ * const rawSchema = zodSchemaRaw(zDoc)
+ * const schema = new Schema(rawSchema)
+ * const userModel = model("User", schema)
+ */
+export declare function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T>;
+export default zodSchema;
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAe,MAAM,UAAU,CAAA;AAClE,OAAO,EAEL,SAAS,EACT,WAAW,EAGX,CAAC,EACF,MAAM,KAAK,CAAA;AAGZ,OAAO,KAAK,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAG3C,cAAc,aAAa,CAAA;AAC3B,cAAc,KAAK,CAAA;AAEnB,OAAO,EAAE,CAAC,EAAE,CAAA;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAC7C,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,GAC3B,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC,CAGhC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAChD,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,GACnB,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAEf;AA6ZD,eAAe,SAAS,CAAA"}

package/dist/schema/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/schema/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/schema/index.test.ts"],"names":[],"mappings":""}

package/dist/schema/mongoose.types.d.ts

@@ -0,0 +1,93 @@
+import { SchemaDefinition, SchemaTypeOptions, SchemaTypes, Types } from '../../../vite/node_modules/mongoose';
+import { ZodType, z } from '../../../vite/node_modules/zod';
+export interface zID extends z.ZodUnion<[
+    z.ZodString,
+    z.ZodType<Types.ObjectId, Types.ObjectId>
+]> {
+    __zm_type: "ObjectId";
+    __zm_ref?: string;
+    __zm_refPath?: string;
+    ref: (ref: string) => zID;
+    unique: (val?: boolean) => zID;
+    sparse: (val?: boolean) => zID;
+    refPath: (ref: string) => zID;
+}
+export interface zUUID extends z.ZodUnion<[
+    z.ZodString,
+    z.ZodType<Types.UUID, Types.UUID>
+]> {
+    __zm_type: "UUID";
+    __zm_ref?: string;
+    __zm_refPath?: string;
+    unique: (val?: boolean) => zUUID;
+    sparse: (val?: boolean) => zUUID;
+    ref: (ref: string) => zUUID;
+    refPath: (ref: string) => zUUID;
+}
+export interface _Field<T> {
+    required: boolean;
+    default?: T;
+    validate?: {
+        validator: (v: T) => boolean;
+        message?: string;
+    };
+}
+export interface mString extends _Field<string> {
+    type: StringConstructor;
+    unique: boolean;
+    sparse: boolean;
+    enum?: string[];
+    match?: RegExp;
+    minLength?: number;
+    maxLength?: number;
+}
+export interface mNumber extends _Field<number> {
+    type: NumberConstructor;
+    unique: boolean;
+    sparse: boolean;
+    min?: number;
+    max?: number;
+}
+export interface mBoolean extends _Field<boolean> {
+    type: BooleanConstructor;
+}
+export interface mDate extends _Field<Date> {
+    type: DateConstructor;
+    unique: boolean;
+    sparse: boolean;
+}
+export interface mObjectId extends _Field<Types.ObjectId> {
+    type: typeof SchemaTypes.ObjectId;
+    unique?: boolean;
+    sparse?: boolean;
+    ref?: string;
+    refPath?: string;
+}
+export interface mUUID extends _Field<Types.UUID> {
+    type: typeof SchemaTypes.UUID;
+    unique?: boolean;
+    sparse?: boolean;
+    ref?: string;
+    refPath?: string;
+}
+export interface mArray<K> extends _Field<K[]> {
+    type: [_Field<K>];
+}
+export interface mMixed<T> extends _Field<T> {
+    type: typeof SchemaTypes.Mixed;
+}
+export type Constructor = StringConstructor | NumberConstructor | ObjectConstructor | DateConstructor | BooleanConstructor | BigIntConstructor | typeof SchemaTypes.ObjectId | typeof SchemaTypes.UUID;
+export interface mMap<T, K> extends _Field<Map<T, K>> {
+    type: typeof Map;
+    of?: _Field<K>;
+}
+export type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown> | mMap<unknown, unknown>;
+export type _Schema<T> = SchemaDefinition & {
+    [K in keyof T]: (_Field<T[K]> & SchemaTypeOptions<T[K]>) | _Schema<T[K]>;
+};
+export type UnwrapZodType<T> = T extends ZodType<infer K> ? K : never;
+export type EffectValidator<T> = {
+    validator: (v: T) => boolean;
+    message?: string;
+};
+//# sourceMappingURL=mongoose.types.d.ts.map

package/dist/schema/mongoose.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.types.d.ts","sourceRoot":"","sources":["../../src/schema/mongoose.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACvF,OAAO,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGrC,MAAM,WAAW,GACf,SAAQ,CAAC,CAAC,QAAQ,CAAC;IACjB,CAAC,CAAC,SAAS;IACX,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC;CAC1C,CAAC;IACF,SAAS,EAAE,UAAU,CAAA;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAA;IACzB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,GAAG,CAAA;IAC9B,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,GAAG,CAAA;IAC9B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAA;CAC9B;AAED,MAAM,WAAW,KACf,SAAQ,CAAC,CAAC,QAAQ,CAAC;IACjB,CAAC,CAAC,SAAS;IACX,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;CAClC,CAAC;IACF,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IAErB,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,KAAK,CAAA;IAChC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,OAAO,KAAK,KAAK,CAAA;IAChC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAA;IAC3B,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,KAAK,CAAA;CAChC;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,CAAC,CAAA;IACX,QAAQ,CAAC,EAAE;QACT,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;QAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB,CAAA;CACF;AAED,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC7C,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC7C,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,OAAO,CAAC;IAC/C,IAAI,EAAE,kBAAkB,CAAA;CACzB;AAED,MAAM,WAAW,KAAM,SAAQ,MAAM,CAAC,IAAI,CAAC;IACzC,IAAI,EAAE,eAAe,CAAA;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC;IACvD,IAAI,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAA;IACjC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,KAAM,SAAQ,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;IAC/C,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAA;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,EAAE,CAAC;IAC5C,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;CAClB;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC1C,IAAI,EAAE,OAAO,WAAW,CAAC,KAAK,CAAA;CAC/B;AAED,MAAM,MAAM,WAAW,GACnB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,OAAO,WAAW,CAAC,QAAQ,GAC3B,OAAO,WAAW,CAAC,IAAI,CAAA;AAE3B,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnD,IAAI,EAAE,OAAO,GAAG,CAAA;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;CACf;AAED,MAAM,MAAM,MAAM,GACd,OAAO,GACP,OAAO,GACP,QAAQ,GACR,KAAK,GACL,SAAS,GACT,KAAK,GACL,MAAM,CAAC,OAAO,CAAC,GACf,MAAM,CAAC,OAAO,CAAC,GACf,OAAO,CAAC,OAAO,CAAC,GAChB,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;AAE1B,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,gBAAgB,GAAG;KACzC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAA;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAErE,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAC/B,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA"}

package/dist/setupFile.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=setupFile.d.ts.map

package/dist/setupFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupFile.d.ts","sourceRoot":"","sources":["../src/setupFile.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@rpcbase/db",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "wireit",
+    "test": "vitest run --coverage",
+    "release": "wireit"
+  },
+  "wireit": {
+    "build": {
+      "command": "../../node_modules/.bin/vite build",
+      "files": [
+        "src/**/*",
+        "../../tsconfig.json",
+        "../../scripts/tsconfig.pkg.json",
+        "./tsconfig.json",
+        "./vite.config.js",
+        "../../scripts/vite.config-pkg.js"
+      ],
+      "output": [
+        "dist/"
+      ]
+    },
+    "build-watch": {
+      "command": "../../node_modules/.bin/vite build --watch",
+      "service": true,
+      "dependencies": [
+        "build"
+      ]
+    },
+    "release": {
+      "command": "../../scripts/publish.js",
+      "dependencies": [
+        "build"
+      ],
+      "files": [
+        "../../scripts/publish.js",
+        "package.json",
+        "dist/**/*"
+      ],
+      "output": [],
+      "env": {
+        "NPM_RELEASE_CHANNEL": {
+          "external": true
+        }
+      }
+    }
+  },
+  "peerDependencies": {
+    "mongoose": "^8",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@vitest/coverage-v8": "4.0.9",
+    "mongoose": "8.19.4",
+    "vitest": "4.0.9"
+  }
+}