@orion-js/schema 4.0.0 → 4.0.2

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   clean: () => clean2,
   cleanAndValidate: () => cleanAndValidate,
   cleanKey: () => cleanKey_default,
+  cloneSchema: () => cloneSchema,
   createEnum: () => createEnum,
   dotGetSchema: () => dotGetSchema_default2,
   fieldTypes: () => fieldTypes_default,
@@ -67,6 +68,35 @@ function type(input) {
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isArray.js
 var { isArray } = Array;
 
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/isInteger.js
+function _isInteger(n) {
+  return n << 0 === n;
+}
+var isInteger = Number.isInteger || _isInteger;
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/_internals/createPath.js
+function createPath(path, delimiter = ".") {
+  return typeof path === "string" ? path.split(delimiter).map((x) => isInteger(x) ? Number(x) : x) : path;
+}
+
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/pick.js
+function pick(propsToPick, input) {
+  if (arguments.length === 1) return (_input) => pick(propsToPick, _input);
+  if (input === null || input === void 0) {
+    return void 0;
+  }
+  const keys = createPath(propsToPick, ",");
+  const willReturn = {};
+  let counter = 0;
+  while (counter < keys.length) {
+    if (keys[counter] in input) {
+      willReturn[keys[counter]] = input[keys[counter]];
+    }
+    counter++;
+  }
+  return willReturn;
+}
+
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isType.js
 function isType(xType, x) {
   if (arguments.length === 1) {
@@ -86,6 +116,21 @@ function clone(input) {
   return out;
 }
 
+// ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isEmpty.js
+function isEmpty(input) {
+  const inputType = type(input);
+  if (["Undefined", "NaN", "Number", "Null"].includes(inputType))
+    return false;
+  if (!input) return true;
+  if (inputType === "Object") {
+    return Object.keys(input).length === 0;
+  }
+  if (inputType === "Array") {
+    return input.length === 0;
+  }
+  return false;
+}
+
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/isNil.js
 function isNil(x) {
   return x === void 0 || x === null;
@@ -503,8 +548,8 @@ function getSchemaWithMetadataFromAnyOrionForm(type2) {
 
 // src/getValidationErrors/getError/index.ts
 async function getValidationErrors(params) {
-  const { schema, doc, currentDoc, value, currentSchema, keys, options = {}, args = [] } = params;
-  const info = { schema, doc, currentDoc, keys, currentSchema, options };
+  const { schema: schema2, doc, currentDoc, value, currentSchema, keys, options = {}, args = [] } = params;
+  const info = { schema: schema2, doc, currentDoc, keys, currentSchema, options };
   if (isNil(value)) {
     if (!currentSchema.optional && !options.omitRequired) {
       return Errors_default.REQUIRED;
@@ -536,11 +581,11 @@ async function getValidationErrors(params) {
 
 // src/getSchemaFromTypedSchema.ts
 Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
-var getSchemaFromTypedSchema = (schema) => {
-  const item = schema;
-  if (!schema[Symbol.metadata]) return item;
-  if (!schema[Symbol.metadata]._isTypedSchema) return item;
-  return schema[Symbol.metadata]._getModel().getSchema();
+var getSchemaFromTypedSchema = (schema2) => {
+  const item = schema2;
+  if (!schema2[Symbol.metadata]) return item;
+  if (!schema2[Symbol.metadata]._isTypedSchema) return item;
+  return schema2[Symbol.metadata]._getModel().getSchema();
 };
 
 // src/getValidationErrors/convertTypedSchema.ts
@@ -569,9 +614,9 @@ function clone2(value) {
 // src/getValidationErrors/doValidation.ts
 async function doValidation(params) {
   convertTypedSchema(params);
-  const { schema, doc, currentDoc, value, currentSchema, keys = [], addError, options, args } = params;
+  const { schema: schema2, doc, currentDoc, value, currentSchema, keys = [], addError, options, args } = params;
   const info = {
-    schema,
+    schema: schema2,
     doc,
     currentDoc,
     value,
@@ -653,8 +698,8 @@ function getValidationErrorsObject(validationErrors) {
 var defaultOptions = {
   omitRequired: false
 };
-async function getValidationErrors2(schema, doc, passedOptions = {}, ...args) {
-  schema = getSchemaFromAnyOrionForm(schema);
+async function getValidationErrors2(schema2, doc, passedOptions = {}, ...args) {
+  schema2 = getSchemaFromAnyOrionForm(schema2);
   const options = { ...defaultOptions, ...passedOptions };
   const errors = [];
   const addError = (keys, code) => {
@@ -664,11 +709,11 @@ async function getValidationErrors2(schema, doc, passedOptions = {}, ...args) {
     });
   };
   await doValidation({
-    schema,
+    schema: schema2,
     doc,
     currentDoc: doc,
     value: doc,
-    currentSchema: { type: schema },
+    currentSchema: { type: schema2 },
     addError,
     options,
     args
@@ -677,16 +722,16 @@ async function getValidationErrors2(schema, doc, passedOptions = {}, ...args) {
 }
 
 // src/validate.ts
-async function validate(schema, doc, passedOptions = {}, ...args) {
-  const validationErrors = await getValidationErrors2(schema, doc, passedOptions, ...args);
+async function validate(schema2, doc, passedOptions = {}, ...args) {
+  const validationErrors = await getValidationErrors2(schema2, doc, passedOptions, ...args);
   if (validationErrors) {
     throw new ValidationError(validationErrors);
   }
 }
 
 // src/isValid.ts
-async function isValid(schema, doc, passedOptions = {}, ...args) {
-  const validationErrors = await getValidationErrors2(schema, doc, passedOptions, ...args);
+async function isValid(schema2, doc, passedOptions = {}, ...args) {
+  const validationErrors = await getValidationErrors2(schema2, doc, passedOptions, ...args);
   return !validationErrors;
 }
 
@@ -698,9 +743,9 @@ function getFieldType(type2) {
 }
 
 // src/clean/getObjectNode.ts
-function getObjectNode(schema, value) {
-  if (type(schema.type) === "Object" && type(value) === "Object") {
-    const result = schema;
+function getObjectNode(schema2, value) {
+  if (type(schema2.type) === "Object" && type(value) === "Object") {
+    const result = schema2;
     return result;
   }
   return null;
@@ -744,17 +789,17 @@ async function cleanType(type2, fieldSchema, value, info, ...args) {
 
 // src/clean/recursiveClean.ts
 var cleanObjectFields = async ({
-  schema,
+  schema: schema2,
   value,
   ...other
 }) => {
-  const keys = Object.keys(schema.type).filter((key) => !key.startsWith("__"));
+  const keys = Object.keys(schema2.type).filter((key) => !key.startsWith("__"));
   const newDoc = {};
   for (const key of keys) {
     try {
       const cleanOptions = {
         ...other,
-        schema: schema.type[key],
+        schema: schema2.type[key],
         value: value[key],
         currentDoc: value
       };
@@ -769,11 +814,11 @@ var cleanObjectFields = async ({
   return newDoc;
 };
 var cleanArrayItems = async ({
-  schema,
+  schema: schema2,
   value,
   ...other
 }) => {
-  const schemaType = schema.type[0];
+  const schemaType = schema2.type[0];
   const promises = value.map(async (item) => {
     const newValue = await clean({
       ...other,
@@ -788,17 +833,17 @@ var cleanArrayItems = async ({
   const result = await Promise.all(promises);
   return result.filter((value2) => value2 !== void 0);
 };
-function getArrayNode(schema, value) {
-  if (Array.isArray(schema.type) && !isNil(value)) {
-    const result = schema;
+function getArrayNode(schema2, value) {
+  if (Array.isArray(schema2.type) && !isNil(value)) {
+    const result = schema2;
     return result;
   }
   return null;
 }
 var clean = async (info) => {
   convertTypedSchema(info);
-  const { schema, args = [], value } = info;
-  const currSchema = schema.type === void 0 ? { type: schema } : schema;
+  const { schema: schema2, args = [], value } = info;
+  const currSchema = schema2.type === void 0 ? { type: schema2 } : schema2;
   const objectSchema = getObjectNode(currSchema, value);
   if (objectSchema) {
     const newDoc = await cleanObjectFields({
@@ -835,12 +880,12 @@ var defaultOptions2 = {
   trimStrings: true,
   removeEmptyStrings: false
 };
-async function clean2(schema, doc, opts = {}, ...args) {
+async function clean2(schema2, doc, opts = {}, ...args) {
   if (!doc) return doc;
-  schema = getSchemaFromAnyOrionForm(schema);
+  schema2 = getSchemaFromAnyOrionForm(schema2);
   const options = { ...defaultOptions2, ...opts };
   const params = {
-    schema: { type: schema },
+    schema: { type: schema2 },
     value: doc,
     doc: options.forceDoc || doc,
     currentDoc: doc,
@@ -869,11 +914,11 @@ var dotGet = function dotGet2(object, path) {
   }
   return null;
 };
-function dotGetSchema_default(schema, path) {
-  if (isNil(schema)) {
+function dotGetSchema_default(schema2, path) {
+  if (isNil(schema2)) {
     throw new Error("You need to pass a schema");
   }
-  return dotGet({ type: schema }, path);
+  return dotGet({ type: schema2 }, path);
 }
 
 // src/dotGetSchema.ts
@@ -883,9 +928,9 @@ var dotGetSchema_default2 = dotGetSchema_default;
 var defaultOptions3 = {
   filter: true
 };
-async function cleanKey_default(schema, key, value, passedOptions = {}, ...args) {
+async function cleanKey_default(schema2, key, value, passedOptions = {}, ...args) {
   const options = { ...defaultOptions3, ...passedOptions };
-  const keySchema = dotGetSchema_default2(schema, key);
+  const keySchema = dotGetSchema_default2(schema2, key);
   if (!keySchema) {
     if (options.filter) {
       return;
@@ -901,9 +946,9 @@ async function cleanKey_default(schema, key, value, passedOptions = {}, ...args)
 var defaultOptions4 = {
   filter: false
 };
-async function validateKey_default(schema, key, value, passedOptions = {}, ...args) {
+async function validateKey_default(schema2, key, value, passedOptions = {}, ...args) {
   const options = { ...defaultOptions4, ...passedOptions };
-  const keySchema = dotGetSchema_default(schema, key);
+  const keySchema = dotGetSchema_default(schema2, key);
   if (!keySchema) {
     if (options.filter) {
       return Errors_default.NOT_IN_SCHEMA;
@@ -966,17 +1011,93 @@ function createEnum(name, values) {
   });
 }
 
+// src/types/fields.ts
+var subSchema = {
+  name: {
+    type: String
+  }
+};
+var schema = {
+  filter: {
+    type: String
+  },
+  sub: {
+    type: subSchema
+  },
+  gender: {
+    type: createEnum("gender", ["male", "female"])
+  },
+  page: {
+    type: "integer",
+    defaultValue: 1,
+    min: 1
+  },
+  limit: {
+    type: "integer",
+    defaultValue: 0,
+    min: 0,
+    max: 200
+  },
+  sortBy: {
+    type: String,
+    optional: true
+  },
+  sortType: {
+    type: String,
+    allowedValues: ["asc", "desc"],
+    optional: true
+  }
+};
+
 // src/cleanAndValidate.ts
-async function cleanAndValidate(schema, doc) {
-  const cleaned = await clean2(schema, doc);
-  await validate(schema, cleaned);
+async function cleanAndValidate(schema2, doc) {
+  const cleaned = await clean2(schema2, doc);
+  await validate(schema2, cleaned);
   return cleaned;
 }
 
 // src/schemaWithName/index.ts
-function schemaWithName(name, schema) {
-  schema.__modelName = name;
-  return schema;
+function schemaWithName(name, schema2) {
+  schema2.__modelName = name;
+  return schema2;
+}
+
+// src/cloneSchema.ts
+function cloneSchema(options) {
+  const { schema: schema2, extendSchema, mapFields, pickFields, omitFields } = options;
+  const originalMetaKeys = Object.keys(schema2).filter((key) => key.startsWith("__"));
+  const originalMetaFields = pick(originalMetaKeys, schema2);
+  const cloned = { ...schema2 };
+  if (pickFields == null ? void 0 : pickFields.length) {
+    for (const key in cloned) {
+      if (!pickFields.includes(key)) {
+        delete cloned[key];
+      }
+    }
+  }
+  if (omitFields == null ? void 0 : omitFields.length) {
+    for (const key in cloned) {
+      if (omitFields.includes(key)) {
+        delete cloned[key];
+      }
+    }
+  }
+  if (!isEmpty(extendSchema)) {
+    for (const key in extendSchema) {
+      cloned[key] = extendSchema[key];
+    }
+  }
+  if (mapFields) {
+    for (const key in cloned) {
+      cloned[key] = mapFields(cloned[key], key);
+    }
+  }
+  for (const key of originalMetaKeys) {
+    if (originalMetaFields[key]) {
+      cloned[key] = originalMetaFields[key];
+    }
+  }
+  return cloned;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -984,6 +1105,7 @@ function schemaWithName(name, schema) {
   clean,
   cleanAndValidate,
   cleanKey,
+  cloneSchema,
   createEnum,
   dotGetSchema,
   fieldTypes,