@classytic/mongokit 3.2.0 → 3.2.2

package/dist/chunks/chunk-I7CWNAJB.js

@@ -1,46 +0,0 @@
-import { __export } from './chunk-WSFCRVEQ.js';
-
-// src/actions/create.ts
-var create_exports = {};
-__export(create_exports, {
-  create: () => create,
-  createDefault: () => createDefault,
-  createMany: () => createMany,
-  upsert: () => upsert
-});
-async function create(Model, data, options = {}) {
-  const document = new Model(data);
-  await document.save({ session: options.session });
-  return document;
-}
-async function createMany(Model, dataArray, options = {}) {
-  return Model.insertMany(dataArray, {
-    session: options.session,
-    ordered: options.ordered !== false
-  });
-}
-async function createDefault(Model, overrides = {}, options = {}) {
-  const defaults = {};
-  Model.schema.eachPath((path, schemaType) => {
-    const schemaOptions = schemaType.options;
-    if (schemaOptions.default !== void 0 && path !== "_id") {
-      defaults[path] = typeof schemaOptions.default === "function" ? schemaOptions.default() : schemaOptions.default;
-    }
-  });
-  return create(Model, { ...defaults, ...overrides }, options);
-}
-async function upsert(Model, query, data, options = {}) {
-  return Model.findOneAndUpdate(
-    query,
-    { $setOnInsert: data },
-    {
-      upsert: true,
-      new: true,
-      runValidators: true,
-      session: options.session,
-      ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-    }
-  );
-}
-
-export { create, createMany, create_exports, upsert };

package/dist/chunks/chunk-JWUAVZ3L.js

@@ -1,8 +0,0 @@
-// src/utils/error.ts
-function createError(status, message) {
-  const error = new Error(message);
-  error.status = status;
-  return error;
-}
-
-export { createError };

package/dist/chunks/chunk-UE2IEXZJ.js

@@ -1,306 +0,0 @@
-import 'mongoose';
-
-// src/utils/memory-cache.ts
-function createMemoryCache(maxEntries = 1e3) {
-  const cache = /* @__PURE__ */ new Map();
-  let lastCleanup = Date.now();
-  const CLEANUP_INTERVAL_MS = 6e4;
-  function cleanupIfNeeded() {
-    const now = Date.now();
-    if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
-    lastCleanup = now;
-    for (const [key, entry] of cache) {
-      if (entry.expiresAt < now) cache.delete(key);
-    }
-  }
-  function evictOldest() {
-    while (cache.size >= maxEntries) {
-      const firstKey = cache.keys().next().value;
-      if (firstKey) cache.delete(firstKey);
-      else break;
-    }
-  }
-  return {
-    async get(key) {
-      const entry = cache.get(key);
-      if (!entry) return null;
-      if (entry.expiresAt < Date.now()) {
-        cache.delete(key);
-        return null;
-      }
-      cache.delete(key);
-      cache.set(key, entry);
-      return entry.value;
-    },
-    async set(key, value, ttl) {
-      cache.delete(key);
-      if (cache.size >= maxEntries) {
-        cleanupIfNeeded();
-        evictOldest();
-      }
-      cache.set(key, {
-        value,
-        expiresAt: Date.now() + ttl * 1e3
-      });
-    },
-    async del(key) {
-      cache.delete(key);
-    },
-    async clear(pattern) {
-      if (!pattern) {
-        cache.clear();
-        return;
-      }
-      const regex = new RegExp(
-        "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
-      );
-      for (const key of cache.keys()) {
-        if (regex.test(key)) {
-          cache.delete(key);
-        }
-      }
-    }
-  };
-}
-function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
-  const jsonCreate = buildJsonSchemaFromPaths(mongooseSchema, options);
-  const jsonUpdate = buildJsonSchemaForUpdate(jsonCreate, options);
-  const jsonParams = {
-    type: "object",
-    properties: { id: { type: "string", pattern: "^[0-9a-fA-F]{24}$" } },
-    required: ["id"]
-  };
-  const tree = mongooseSchema?.obj || {};
-  const jsonQuery = buildJsonSchemaForQuery(tree, options);
-  return { createBody: jsonCreate, updateBody: jsonUpdate, params: jsonParams, listQuery: jsonQuery };
-}
-function buildCrudSchemasFromModel(mongooseModel, options = {}) {
-  if (!mongooseModel || !mongooseModel.schema) {
-    throw new Error("Invalid mongoose model");
-  }
-  return buildCrudSchemasFromMongooseSchema(mongooseModel.schema, options);
-}
-function getImmutableFields(options = {}) {
-  const immutable = [];
-  const fieldRules = options?.fieldRules || {};
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.immutable || rules.immutableAfterCreate) {
-      immutable.push(field);
-    }
-  });
-  (options?.update?.omitFields || []).forEach((f) => {
-    if (!immutable.includes(f)) immutable.push(f);
-  });
-  return immutable;
-}
-function getSystemManagedFields(options = {}) {
-  const systemManaged = [];
-  const fieldRules = options?.fieldRules || {};
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.systemManaged) {
-      systemManaged.push(field);
-    }
-  });
-  return systemManaged;
-}
-function isFieldUpdateAllowed(fieldName, options = {}) {
-  const immutableFields = getImmutableFields(options);
-  const systemManagedFields = getSystemManagedFields(options);
-  return !immutableFields.includes(fieldName) && !systemManagedFields.includes(fieldName);
-}
-function validateUpdateBody(body = {}, options = {}) {
-  const violations = [];
-  const immutableFields = getImmutableFields(options);
-  const systemManagedFields = getSystemManagedFields(options);
-  Object.keys(body).forEach((field) => {
-    if (immutableFields.includes(field)) {
-      violations.push({ field, reason: "Field is immutable" });
-    } else if (systemManagedFields.includes(field)) {
-      violations.push({ field, reason: "Field is system-managed" });
-    }
-  });
-  return {
-    valid: violations.length === 0,
-    violations
-  };
-}
-function buildJsonSchemaFromPaths(mongooseSchema, options) {
-  const properties = {};
-  const required = [];
-  const paths = mongooseSchema.paths;
-  const rootFields = /* @__PURE__ */ new Map();
-  for (const [path, schemaType] of Object.entries(paths)) {
-    if (path === "_id" || path === "__v") continue;
-    const parts = path.split(".");
-    const rootField = parts[0];
-    if (!rootFields.has(rootField)) {
-      rootFields.set(rootField, []);
-    }
-    rootFields.get(rootField).push({ path, schemaType });
-  }
-  for (const [rootField, fieldPaths] of rootFields.entries()) {
-    if (fieldPaths.length === 1 && fieldPaths[0].path === rootField) {
-      const schemaType = fieldPaths[0].schemaType;
-      properties[rootField] = schemaTypeToJsonSchema(schemaType);
-      if (schemaType.isRequired) {
-        required.push(rootField);
-      }
-    } else {
-      const nestedSchema = buildNestedJsonSchema(fieldPaths, rootField);
-      properties[rootField] = nestedSchema.schema;
-      if (nestedSchema.required) {
-        required.push(rootField);
-      }
-    }
-  }
-  const schema = { type: "object", properties };
-  if (required.length) schema.required = required;
-  const fieldsToOmit = /* @__PURE__ */ new Set(["createdAt", "updatedAt", "__v"]);
-  (options?.create?.omitFields || []).forEach((f) => fieldsToOmit.add(f));
-  const fieldRules = options?.fieldRules || {};
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.systemManaged) {
-      fieldsToOmit.add(field);
-    }
-  });
-  fieldsToOmit.forEach((field) => {
-    if (schema.properties?.[field]) {
-      delete schema.properties[field];
-    }
-    if (schema.required) {
-      schema.required = schema.required.filter((k) => k !== field);
-    }
-  });
-  const reqOv = options?.create?.requiredOverrides || {};
-  const optOv = options?.create?.optionalOverrides || {};
-  schema.required = schema.required || [];
-  for (const [k, v] of Object.entries(reqOv)) {
-    if (v && !schema.required.includes(k)) schema.required.push(k);
-  }
-  for (const [k, v] of Object.entries(optOv)) {
-    if (v && schema.required) schema.required = schema.required.filter((x) => x !== k);
-  }
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.optional && schema.required) {
-      schema.required = schema.required.filter((x) => x !== field);
-    }
-  });
-  const schemaOverrides = options?.create?.schemaOverrides || {};
-  for (const [k, override] of Object.entries(schemaOverrides)) {
-    if (schema.properties?.[k]) {
-      schema.properties[k] = override;
-    }
-  }
-  if (options?.strictAdditionalProperties === true) {
-    schema.additionalProperties = false;
-  }
-  return schema;
-}
-function buildNestedJsonSchema(fieldPaths, rootField) {
-  const properties = {};
-  const required = [];
-  let hasRequiredFields = false;
-  for (const { path, schemaType } of fieldPaths) {
-    const relativePath = path.substring(rootField.length + 1);
-    const parts = relativePath.split(".");
-    if (parts.length === 1) {
-      properties[parts[0]] = schemaTypeToJsonSchema(schemaType);
-      if (schemaType.isRequired) {
-        required.push(parts[0]);
-        hasRequiredFields = true;
-      }
-    } else {
-      const fieldName = parts[0];
-      if (!properties[fieldName]) {
-        properties[fieldName] = { type: "object", properties: {} };
-      }
-      const nestedObj = properties[fieldName];
-      if (!nestedObj.properties) nestedObj.properties = {};
-      const deepPath = parts.slice(1).join(".");
-      nestedObj.properties[deepPath] = schemaTypeToJsonSchema(schemaType);
-    }
-  }
-  const schema = { type: "object", properties };
-  if (required.length) schema.required = required;
-  return { schema, required: hasRequiredFields };
-}
-function schemaTypeToJsonSchema(schemaType) {
-  const result = {};
-  const instance = schemaType.instance;
-  const options = schemaType.options || {};
-  if (instance === "String") {
-    result.type = "string";
-    if (typeof options.minlength === "number") result.minLength = options.minlength;
-    if (typeof options.maxlength === "number") result.maxLength = options.maxlength;
-    if (options.match instanceof RegExp) result.pattern = options.match.source;
-    if (options.enum && Array.isArray(options.enum)) result.enum = options.enum;
-  } else if (instance === "Number") {
-    result.type = "number";
-    if (typeof options.min === "number") result.minimum = options.min;
-    if (typeof options.max === "number") result.maximum = options.max;
-  } else if (instance === "Boolean") {
-    result.type = "boolean";
-  } else if (instance === "Date") {
-    result.type = "string";
-    result.format = "date-time";
-  } else if (instance === "ObjectId" || instance === "ObjectID") {
-    result.type = "string";
-    result.pattern = "^[0-9a-fA-F]{24}$";
-  } else if (instance === "Array") {
-    result.type = "array";
-    result.items = { type: "string" };
-  } else {
-    result.type = "object";
-    result.additionalProperties = true;
-  }
-  return result;
-}
-function buildJsonSchemaForUpdate(createJson, options) {
-  const clone = JSON.parse(JSON.stringify(createJson));
-  delete clone.required;
-  const fieldsToOmit = /* @__PURE__ */ new Set();
-  (options?.update?.omitFields || []).forEach((f) => fieldsToOmit.add(f));
-  const fieldRules = options?.fieldRules || {};
-  Object.entries(fieldRules).forEach(([field, rules]) => {
-    if (rules.immutable || rules.immutableAfterCreate) {
-      fieldsToOmit.add(field);
-    }
-  });
-  fieldsToOmit.forEach((field) => {
-    if (clone.properties?.[field]) {
-      delete clone.properties[field];
-    }
-  });
-  if (options?.strictAdditionalProperties === true) {
-    clone.additionalProperties = false;
-  }
-  if (options?.update?.requireAtLeastOne === true) {
-    clone.minProperties = 1;
-  }
-  return clone;
-}
-function buildJsonSchemaForQuery(_tree, options) {
-  const basePagination = {
-    type: "object",
-    properties: {
-      page: { type: "string" },
-      limit: { type: "string" },
-      sort: { type: "string" },
-      populate: { type: "string" },
-      search: { type: "string" },
-      select: { type: "string" },
-      lean: { type: "string" },
-      includeDeleted: { type: "string" }
-    },
-    additionalProperties: true
-  };
-  const filterable = options?.query?.filterableFields || {};
-  for (const [k, v] of Object.entries(filterable)) {
-    if (basePagination.properties) {
-      basePagination.properties[k] = v && typeof v === "object" && "type" in v ? v : { type: "string" };
-    }
-  }
-  return basePagination;
-}
-
-export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, createMemoryCache, getImmutableFields, getSystemManagedFields, isFieldUpdateAllowed, validateUpdateBody };

package/dist/chunks/chunk-URLJFIR7.js

@@ -1,22 +0,0 @@
-// src/utils/logger.ts
-var noop = () => {
-};
-var current = {
-  warn: console.warn.bind(console),
-  debug: noop
-};
-function configureLogger(config) {
-  if (config === false) {
-    current = { warn: noop, debug: noop };
-  } else {
-    current = { ...current, ...config };
-  }
-}
-function warn(message, ...args) {
-  current.warn(message, ...args);
-}
-function debug(message, ...args) {
-  current.debug(message, ...args);
-}
-
-export { configureLogger, debug, warn };