bguard 0.0.3 → 0.0.5

package/lib/__tests__/MixTypes.test.js

@@ -0,0 +1,165 @@
+"use strict";
+
+// jest/setup.ts
+function expectEqualTypes(areEqual) {
+  expect(typeof areEqual).toBe("boolean");
+}
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) throwException("Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) throwException("Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      throwException("Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      throwException("Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      throwException(
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        throwException("Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          throwException(
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return innerCheck(schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  [ctxSymbol];
+  constructor(ctx) {
+    this[ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+// src/asserts/common/index.ts
+function oneOfTypes(valueTypes) {
+  return new CommonSchema({ type: valueTypes, requiredValidations: [] });
+}
+
+// src/__tests__/MixTypes.test.ts
+describe("MixTypes", () => {
+  it("should be a string or number", () => {
+    const stringOrNumberSchema = oneOfTypes(["number", "string"]);
+    expectEqualTypes(true);
+    expect(parseSchema(stringOrNumberSchema, "this is a string")).toBe("this is a string");
+    expect(parseSchema(stringOrNumberSchema, 5)).toBe(5);
+    expect(() => parseSchema(stringOrNumberSchema, true)).toThrow("Invalid type of data");
+    const stringOrBooleanOrUndefinedSchema = oneOfTypes(["boolean", "string"]).optional();
+    expectEqualTypes(true);
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, "this is a string")).toBe("this is a string");
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, true)).toBe(true);
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, void 0)).toBe(void 0);
+    expect(() => parseSchema(stringOrBooleanOrUndefinedSchema, 5)).toThrow("Invalid type of data");
+    const functionOrBooleanOrUndefinedOrNullSchema = oneOfTypes(["boolean", "function"]).optional().nullable();
+    expectEqualTypes(
+      true
+    );
+    const receivedFunc = () => {
+    };
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, receivedFunc)).toBe(receivedFunc);
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, true)).toBe(true);
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, void 0)).toBe(void 0);
+    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 5)).toThrow("Invalid type of data");
+    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, "this is a string")).toThrow(
+      "Invalid type of data"
+    );
+  });
+});
+//# sourceMappingURL=MixTypes.test.js.map

package/lib/__tests__/MixTypes.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../jest/setup.ts","../../src/exceptions.ts","../../src/core.ts","../../src/parseSchema.ts","../../src/schemas/CommonSchema.ts","../../src/asserts/common/index.ts","../../src/__tests__/MixTypes.test.ts"],"sourcesContent":["export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;\n\nexport function expectEqualTypes<X, Y>(areEqual: Equal<X, Y>): void {\n  expect(typeof areEqual).toBe('boolean');\n}\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","export const ctxSymbol = Symbol('contextSymbol');\n\nimport { throwException } from './exceptions';\nimport type { CommonSchema } from './schemas/CommonSchema';\n\nexport function innerCheck(schema: CommonSchema, receivedValue: unknown, pathToError: string) {\n  const ctx = schema[ctxSymbol];\n  if (receivedValue === undefined) {\n    if (!ctx.isOptional) throwException('Required', receivedValue, pathToError, 'The required value is missing');\n    return receivedValue;\n  }\n\n  if (receivedValue === null) {\n    if (!ctx.isNullable) throwException('Not null', receivedValue, pathToError, 'Value should not be null');\n    return receivedValue;\n  }\n\n  if (ctx.array) {\n    if (!Array.isArray(receivedValue))\n      throwException('Array', receivedValue, pathToError, 'Expected an array but received a different type');\n    const schema = ctx.array;\n\n    receivedValue.forEach((elem, i) => {\n      innerCheck(schema, elem, `${pathToError}[${i}]`);\n    });\n\n    return receivedValue;\n  }\n\n  const typeOfVal = typeof receivedValue;\n\n  if (ctx.object) {\n    if (typeOfVal !== 'object')\n      throwException('Object', receivedValue, pathToError, 'Expected an object but received a different type');\n    if (Array.isArray(receivedValue))\n      throwException(\n        'Object',\n        receivedValue,\n        pathToError,\n        'Expected an object but received an array. Invalid type of data',\n      );\n    const shapeSchema = ctx.object;\n    for (const keyPerReceivedValue of Object.keys(receivedValue)) {\n      if (shapeSchema[keyPerReceivedValue] === undefined)\n        throwException('Not allowed', keyPerReceivedValue, pathToError, 'This key is not allowed in the object');\n    }\n\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {\n      const receivedObjectValuePropery = (receivedValue as Record<string, unknown>)[keyOfSchema];\n      if (receivedObjectValuePropery === undefined) {\n        if (!valueOfSchema[ctxSymbol].isOptional)\n          throwException(\n            'Required',\n            receivedObjectValuePropery,\n            pathToError,\n            'Missing required property in the object',\n          );\n      }\n      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);\n    }\n\n    return receivedValue;\n  }\n\n  if (ctx.type.length) {\n    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, 'Invalid type of data');\n  }\n\n  ctx.requiredValidations.forEach((requiredValidation) => {\n    requiredValidation(receivedValue, pathToError);\n  });\n\n  return receivedValue;\n}\n","import { InferType } from './InferType';\nimport { innerCheck } from './core';\nimport { ValidationError } from './exceptions';\nimport { CommonSchema } from './schemas/CommonSchema';\n\n/**\n * Parses and validates a value against the provided schema, returning a type-safe result.\n *\n * This function will throw a `ValidationError` if the value does not conform to the schema.\n * The inferred TypeScript type of the returned value will match the structure defined by the schema.\n *\n * @template T\n * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.\n * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.\n * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.\n *\n * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.\n * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number(),\n * });\n *\n * const result = parseSchema(schema, { name: 'Alice', age: 30 });\n * // result will be inferred as { name: string; age: number }\n *\n * parseSchema(schema, { name: 'Alice', age: '30' });\n * // Throws ValidationError because 'age' should be a number, not a string.\n */\nexport function parseSchema<T extends CommonSchema>(schema: T, receivedValue: unknown): InferType<T> {\n  try {\n    return innerCheck(schema, receivedValue, '') as InferType<T>;\n  } catch (e) {\n    if (e instanceof ValidationError) throw e;\n    /* istanbul ignore next */\n    throw new Error('Something unexpected happened');\n  }\n}\n","import { ctxSymbol } from '../core';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequiredValidation = (received: any, pathToError: string) => void;\nexport type ObjectShapeSchemaType = Record<string, CommonSchema>;\n\nexport type PrimitiveType = 'number' | 'string' | 'boolean' | 'undefined' | 'object' | 'function' | 'symbol' | 'bigint';\nexport interface ValidatorContext {\n  type: PrimitiveType[];\n  isNullable?: boolean;\n  isOptional?: boolean;\n  requiredValidations: RequiredValidation[];\n  array?: CommonSchema;\n  object?: ObjectShapeSchemaType;\n}\n\nexport class CommonSchema {\n  [ctxSymbol]: ValidatorContext;\n  constructor(ctx: ValidatorContext) {\n    this[ctxSymbol] = ctx;\n  }\n\n  /**\n   * @param validators - One or more custom validation functions.\n   * @returns {this} The schema instance with the added custom validation.\n   */\n  custom(...validators: RequiredValidation[]): this {\n    this[ctxSymbol].requiredValidations.push(...validators);\n    return this;\n  }\n\n  /**\n   * Marks the schema as nullable, allowing the value to be `null`.\n   *\n   * @returns {WithNull<this>} The schema instance marked as nullable.\n   */\n  nullable(): WithNull<this> {\n    this[ctxSymbol].isNullable = true;\n    return this as WithNull<this>;\n  }\n\n  /**\n   * Marks the schema as optional, allowing the value to be `undefined`.\n   *\n   * @returns {WithUndefined<this>}} The schema instance marked as optional.\n   */\n  optional(): WithUndefined<this> {\n    this[ctxSymbol].isOptional = true;\n    return this as WithUndefined<this>;\n  }\n}\n\nexport type WithNull<T extends CommonSchema> = T & { validation_null: true };\nexport type WithUndefined<T extends CommonSchema> = T & { validation_undefined: true };\n\ntype TypeMapping = {\n  number: number;\n  string: string;\n  boolean: boolean;\n  undefined: undefined;\n  object: object;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  function: Function;\n  symbol: symbol;\n  bigint: bigint;\n};\n\nexport type WithMix<Y = unknown> = CommonSchema & { validation_mix: Y };\nexport type ExtractFromMix<T> = T extends WithMix<infer X> ? X : never;\n\nexport type MapMixTypes<T extends PrimitiveType[]> = T extends (infer U)[]\n  ? U extends keyof TypeMapping\n    ? TypeMapping[U]\n    : never\n  : never;\n","import { CommonSchema, MapMixTypes, PrimitiveType, WithMix } from '../../schemas/CommonSchema';\n\n/**\n * Creates a new schema for validating values that can match any one of the specified primitive types.\n *\n * @template T\n * @param {T} valueTypes - An array of primitive types that the value can match.\n * @returns {WithMix<MapMixTypes<T>>} A new schema for validating values that can match any of the specified types.\n *\n * @example\n * const schema = oneOfTypes(['string', 'number']);\n * parseSchema(schema, 'hello'); // Validates successfully\n * parseSchema(schema, 42); // Validates successfully\n * parseSchema(schema, true); // Throws a validation error\n */\nexport function oneOfTypes<T extends PrimitiveType[]>(valueTypes: T): WithMix<MapMixTypes<T>> {\n  return new CommonSchema({ type: valueTypes, requiredValidations: [] }) as WithMix<MapMixTypes<T>>;\n}\n","import { expectEqualTypes } from '../../jest/setup';\nimport { parseSchema } from '../parseSchema';\nimport { InferType, oneOfTypes } from '../';\n\ndescribe('MixTypes', () => {\n  it('should be a string or number', () => {\n    const stringOrNumberSchema = oneOfTypes(['number', 'string']);\n\n    expectEqualTypes<string | number, InferType<typeof stringOrNumberSchema>>(true);\n    expect(parseSchema(stringOrNumberSchema, 'this is a string')).toBe('this is a string');\n    expect(parseSchema(stringOrNumberSchema, 5)).toBe(5);\n    expect(() => parseSchema(stringOrNumberSchema, true)).toThrow('Invalid type of data');\n\n    const stringOrBooleanOrUndefinedSchema = oneOfTypes(['boolean', 'string']).optional();\n\n    expectEqualTypes<string | boolean | undefined, InferType<typeof stringOrBooleanOrUndefinedSchema>>(true);\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, 'this is a string')).toBe('this is a string');\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, true)).toBe(true);\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, undefined)).toBe(undefined);\n    expect(() => parseSchema(stringOrBooleanOrUndefinedSchema, 5)).toThrow('Invalid type of data');\n\n    const functionOrBooleanOrUndefinedOrNullSchema = oneOfTypes(['boolean', 'function']).optional().nullable();\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    expectEqualTypes<boolean | Function | null | undefined, InferType<typeof functionOrBooleanOrUndefinedOrNullSchema>>(\n      true,\n    );\n    const receivedFunc = () => {};\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, receivedFunc)).toBe(receivedFunc);\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, true)).toBe(true);\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, undefined)).toBe(undefined);\n    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 5)).toThrow('Invalid type of data');\n    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 'this is a string')).toThrow(\n      'Invalid type of data',\n    );\n  });\n});\n"],"mappings":"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","names":["schema"]}

package/lib/__tests__/MixTypes.test.mjs

@@ -0,0 +1,163 @@
+// jest/setup.ts
+function expectEqualTypes(areEqual) {
+  expect(typeof areEqual).toBe("boolean");
+}
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) throwException("Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) throwException("Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      throwException("Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      throwException("Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      throwException(
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        throwException("Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          throwException(
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return innerCheck(schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  [ctxSymbol];
+  constructor(ctx) {
+    this[ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+// src/asserts/common/index.ts
+function oneOfTypes(valueTypes) {
+  return new CommonSchema({ type: valueTypes, requiredValidations: [] });
+}
+
+// src/__tests__/MixTypes.test.ts
+describe("MixTypes", () => {
+  it("should be a string or number", () => {
+    const stringOrNumberSchema = oneOfTypes(["number", "string"]);
+    expectEqualTypes(true);
+    expect(parseSchema(stringOrNumberSchema, "this is a string")).toBe("this is a string");
+    expect(parseSchema(stringOrNumberSchema, 5)).toBe(5);
+    expect(() => parseSchema(stringOrNumberSchema, true)).toThrow("Invalid type of data");
+    const stringOrBooleanOrUndefinedSchema = oneOfTypes(["boolean", "string"]).optional();
+    expectEqualTypes(true);
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, "this is a string")).toBe("this is a string");
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, true)).toBe(true);
+    expect(parseSchema(stringOrBooleanOrUndefinedSchema, void 0)).toBe(void 0);
+    expect(() => parseSchema(stringOrBooleanOrUndefinedSchema, 5)).toThrow("Invalid type of data");
+    const functionOrBooleanOrUndefinedOrNullSchema = oneOfTypes(["boolean", "function"]).optional().nullable();
+    expectEqualTypes(
+      true
+    );
+    const receivedFunc = () => {
+    };
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, receivedFunc)).toBe(receivedFunc);
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, true)).toBe(true);
+    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, void 0)).toBe(void 0);
+    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 5)).toThrow("Invalid type of data");
+    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, "this is a string")).toThrow(
+      "Invalid type of data"
+    );
+  });
+});
+//# sourceMappingURL=MixTypes.test.mjs.map

package/lib/__tests__/MixTypes.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../jest/setup.ts","../../src/exceptions.ts","../../src/core.ts","../../src/parseSchema.ts","../../src/schemas/CommonSchema.ts","../../src/asserts/common/index.ts","../../src/__tests__/MixTypes.test.ts"],"sourcesContent":["export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;\n\nexport function expectEqualTypes<X, Y>(areEqual: Equal<X, Y>): void {\n  expect(typeof areEqual).toBe('boolean');\n}\n","export class ValidationError extends Error {\n  expected: unknown;\n  received: unknown;\n  pathToError: string;\n  message: string;\n  constructor(expected: unknown, received: unknown, pathToError: string, message: string) {\n    super();\n    this.expected = expected;\n    this.received = received;\n    this.pathToError = pathToError;\n    this.message = message;\n  }\n}\n\nexport class BuildSchemaError extends Error {}\n\nexport function throwException(expected: unknown, received: unknown, pathToError: string, message: string): never {\n  throw new ValidationError(expected, received, pathToError, message);\n}\n","export const ctxSymbol = Symbol('contextSymbol');\n\nimport { throwException } from './exceptions';\nimport type { CommonSchema } from './schemas/CommonSchema';\n\nexport function innerCheck(schema: CommonSchema, receivedValue: unknown, pathToError: string) {\n  const ctx = schema[ctxSymbol];\n  if (receivedValue === undefined) {\n    if (!ctx.isOptional) throwException('Required', receivedValue, pathToError, 'The required value is missing');\n    return receivedValue;\n  }\n\n  if (receivedValue === null) {\n    if (!ctx.isNullable) throwException('Not null', receivedValue, pathToError, 'Value should not be null');\n    return receivedValue;\n  }\n\n  if (ctx.array) {\n    if (!Array.isArray(receivedValue))\n      throwException('Array', receivedValue, pathToError, 'Expected an array but received a different type');\n    const schema = ctx.array;\n\n    receivedValue.forEach((elem, i) => {\n      innerCheck(schema, elem, `${pathToError}[${i}]`);\n    });\n\n    return receivedValue;\n  }\n\n  const typeOfVal = typeof receivedValue;\n\n  if (ctx.object) {\n    if (typeOfVal !== 'object')\n      throwException('Object', receivedValue, pathToError, 'Expected an object but received a different type');\n    if (Array.isArray(receivedValue))\n      throwException(\n        'Object',\n        receivedValue,\n        pathToError,\n        'Expected an object but received an array. Invalid type of data',\n      );\n    const shapeSchema = ctx.object;\n    for (const keyPerReceivedValue of Object.keys(receivedValue)) {\n      if (shapeSchema[keyPerReceivedValue] === undefined)\n        throwException('Not allowed', keyPerReceivedValue, pathToError, 'This key is not allowed in the object');\n    }\n\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {\n      const receivedObjectValuePropery = (receivedValue as Record<string, unknown>)[keyOfSchema];\n      if (receivedObjectValuePropery === undefined) {\n        if (!valueOfSchema[ctxSymbol].isOptional)\n          throwException(\n            'Required',\n            receivedObjectValuePropery,\n            pathToError,\n            'Missing required property in the object',\n          );\n      }\n      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);\n    }\n\n    return receivedValue;\n  }\n\n  if (ctx.type.length) {\n    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, 'Invalid type of data');\n  }\n\n  ctx.requiredValidations.forEach((requiredValidation) => {\n    requiredValidation(receivedValue, pathToError);\n  });\n\n  return receivedValue;\n}\n","import { InferType } from './InferType';\nimport { innerCheck } from './core';\nimport { ValidationError } from './exceptions';\nimport { CommonSchema } from './schemas/CommonSchema';\n\n/**\n * Parses and validates a value against the provided schema, returning a type-safe result.\n *\n * This function will throw a `ValidationError` if the value does not conform to the schema.\n * The inferred TypeScript type of the returned value will match the structure defined by the schema.\n *\n * @template T\n * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.\n * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.\n * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.\n *\n * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.\n * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number(),\n * });\n *\n * const result = parseSchema(schema, { name: 'Alice', age: 30 });\n * // result will be inferred as { name: string; age: number }\n *\n * parseSchema(schema, { name: 'Alice', age: '30' });\n * // Throws ValidationError because 'age' should be a number, not a string.\n */\nexport function parseSchema<T extends CommonSchema>(schema: T, receivedValue: unknown): InferType<T> {\n  try {\n    return innerCheck(schema, receivedValue, '') as InferType<T>;\n  } catch (e) {\n    if (e instanceof ValidationError) throw e;\n    /* istanbul ignore next */\n    throw new Error('Something unexpected happened');\n  }\n}\n","import { ctxSymbol } from '../core';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequiredValidation = (received: any, pathToError: string) => void;\nexport type ObjectShapeSchemaType = Record<string, CommonSchema>;\n\nexport type PrimitiveType = 'number' | 'string' | 'boolean' | 'undefined' | 'object' | 'function' | 'symbol' | 'bigint';\nexport interface ValidatorContext {\n  type: PrimitiveType[];\n  isNullable?: boolean;\n  isOptional?: boolean;\n  requiredValidations: RequiredValidation[];\n  array?: CommonSchema;\n  object?: ObjectShapeSchemaType;\n}\n\nexport class CommonSchema {\n  [ctxSymbol]: ValidatorContext;\n  constructor(ctx: ValidatorContext) {\n    this[ctxSymbol] = ctx;\n  }\n\n  /**\n   * @param validators - One or more custom validation functions.\n   * @returns {this} The schema instance with the added custom validation.\n   */\n  custom(...validators: RequiredValidation[]): this {\n    this[ctxSymbol].requiredValidations.push(...validators);\n    return this;\n  }\n\n  /**\n   * Marks the schema as nullable, allowing the value to be `null`.\n   *\n   * @returns {WithNull<this>} The schema instance marked as nullable.\n   */\n  nullable(): WithNull<this> {\n    this[ctxSymbol].isNullable = true;\n    return this as WithNull<this>;\n  }\n\n  /**\n   * Marks the schema as optional, allowing the value to be `undefined`.\n   *\n   * @returns {WithUndefined<this>}} The schema instance marked as optional.\n   */\n  optional(): WithUndefined<this> {\n    this[ctxSymbol].isOptional = true;\n    return this as WithUndefined<this>;\n  }\n}\n\nexport type WithNull<T extends CommonSchema> = T & { validation_null: true };\nexport type WithUndefined<T extends CommonSchema> = T & { validation_undefined: true };\n\ntype TypeMapping = {\n  number: number;\n  string: string;\n  boolean: boolean;\n  undefined: undefined;\n  object: object;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  function: Function;\n  symbol: symbol;\n  bigint: bigint;\n};\n\nexport type WithMix<Y = unknown> = CommonSchema & { validation_mix: Y };\nexport type ExtractFromMix<T> = T extends WithMix<infer X> ? X : never;\n\nexport type MapMixTypes<T extends PrimitiveType[]> = T extends (infer U)[]\n  ? U extends keyof TypeMapping\n    ? TypeMapping[U]\n    : never\n  : never;\n","import { CommonSchema, MapMixTypes, PrimitiveType, WithMix } from '../../schemas/CommonSchema';\n\n/**\n * Creates a new schema for validating values that can match any one of the specified primitive types.\n *\n * @template T\n * @param {T} valueTypes - An array of primitive types that the value can match.\n * @returns {WithMix<MapMixTypes<T>>} A new schema for validating values that can match any of the specified types.\n *\n * @example\n * const schema = oneOfTypes(['string', 'number']);\n * parseSchema(schema, 'hello'); // Validates successfully\n * parseSchema(schema, 42); // Validates successfully\n * parseSchema(schema, true); // Throws a validation error\n */\nexport function oneOfTypes<T extends PrimitiveType[]>(valueTypes: T): WithMix<MapMixTypes<T>> {\n  return new CommonSchema({ type: valueTypes, requiredValidations: [] }) as WithMix<MapMixTypes<T>>;\n}\n","import { expectEqualTypes } from '../../jest/setup';\nimport { parseSchema } from '../parseSchema';\nimport { InferType, oneOfTypes } from '../';\n\ndescribe('MixTypes', () => {\n  it('should be a string or number', () => {\n    const stringOrNumberSchema = oneOfTypes(['number', 'string']);\n\n    expectEqualTypes<string | number, InferType<typeof stringOrNumberSchema>>(true);\n    expect(parseSchema(stringOrNumberSchema, 'this is a string')).toBe('this is a string');\n    expect(parseSchema(stringOrNumberSchema, 5)).toBe(5);\n    expect(() => parseSchema(stringOrNumberSchema, true)).toThrow('Invalid type of data');\n\n    const stringOrBooleanOrUndefinedSchema = oneOfTypes(['boolean', 'string']).optional();\n\n    expectEqualTypes<string | boolean | undefined, InferType<typeof stringOrBooleanOrUndefinedSchema>>(true);\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, 'this is a string')).toBe('this is a string');\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, true)).toBe(true);\n    expect(parseSchema(stringOrBooleanOrUndefinedSchema, undefined)).toBe(undefined);\n    expect(() => parseSchema(stringOrBooleanOrUndefinedSchema, 5)).toThrow('Invalid type of data');\n\n    const functionOrBooleanOrUndefinedOrNullSchema = oneOfTypes(['boolean', 'function']).optional().nullable();\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n    expectEqualTypes<boolean | Function | null | undefined, InferType<typeof functionOrBooleanOrUndefinedOrNullSchema>>(\n      true,\n    );\n    const receivedFunc = () => {};\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, receivedFunc)).toBe(receivedFunc);\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, true)).toBe(true);\n    expect(parseSchema(functionOrBooleanOrUndefinedOrNullSchema, undefined)).toBe(undefined);\n    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 5)).toThrow('Invalid type of data');\n    expect(() => parseSchema(functionOrBooleanOrUndefinedOrNullSchema, 'this is a string')).toThrow(\n      'Invalid type of data',\n    );\n  });\n});\n"],"mappings":"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","names":["schema"]}

package/lib/__tests__/NumberSchema.test.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/__tests__/NumberSchema.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/lib/__tests__/NumberSchema.test.js

@@ -0,0 +1,253 @@
+"use strict";
+
+// jest/setup.ts
+function expectEqualTypes(areEqual) {
+  expect(typeof areEqual).toBe("boolean");
+}
+
+// src/exceptions.ts
+var ValidationError = class extends Error {
+  expected;
+  received;
+  pathToError;
+  message;
+  constructor(expected, received, pathToError, message) {
+    super();
+    this.expected = expected;
+    this.received = received;
+    this.pathToError = pathToError;
+    this.message = message;
+  }
+};
+function throwException(expected, received, pathToError, message) {
+  throw new ValidationError(expected, received, pathToError, message);
+}
+
+// src/core.ts
+var ctxSymbol = Symbol("contextSymbol");
+function innerCheck(schema, receivedValue, pathToError) {
+  const ctx = schema[ctxSymbol];
+  if (receivedValue === void 0) {
+    if (!ctx.isOptional) throwException("Required", receivedValue, pathToError, "The required value is missing");
+    return receivedValue;
+  }
+  if (receivedValue === null) {
+    if (!ctx.isNullable) throwException("Not null", receivedValue, pathToError, "Value should not be null");
+    return receivedValue;
+  }
+  if (ctx.array) {
+    if (!Array.isArray(receivedValue))
+      throwException("Array", receivedValue, pathToError, "Expected an array but received a different type");
+    const schema2 = ctx.array;
+    receivedValue.forEach((elem, i) => {
+      innerCheck(schema2, elem, `${pathToError}[${i}]`);
+    });
+    return receivedValue;
+  }
+  const typeOfVal = typeof receivedValue;
+  if (ctx.object) {
+    if (typeOfVal !== "object")
+      throwException("Object", receivedValue, pathToError, "Expected an object but received a different type");
+    if (Array.isArray(receivedValue))
+      throwException(
+        "Object",
+        receivedValue,
+        pathToError,
+        "Expected an object but received an array. Invalid type of data"
+      );
+    const shapeSchema = ctx.object;
+    for (const keyPerReceivedValue of Object.keys(receivedValue)) {
+      if (shapeSchema[keyPerReceivedValue] === void 0)
+        throwException("Not allowed", keyPerReceivedValue, pathToError, "This key is not allowed in the object");
+    }
+    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {
+      const receivedObjectValuePropery = receivedValue[keyOfSchema];
+      if (receivedObjectValuePropery === void 0) {
+        if (!valueOfSchema[ctxSymbol].isOptional)
+          throwException(
+            "Required",
+            receivedObjectValuePropery,
+            pathToError,
+            "Missing required property in the object"
+          );
+      }
+      innerCheck(valueOfSchema, receivedObjectValuePropery, `${pathToError}.${keyOfSchema}`);
+    }
+    return receivedValue;
+  }
+  if (ctx.type.length) {
+    if (!ctx.type.includes(typeOfVal)) throwException(ctx.type, typeOfVal, pathToError, "Invalid type of data");
+  }
+  ctx.requiredValidations.forEach((requiredValidation) => {
+    requiredValidation(receivedValue, pathToError);
+  });
+  return receivedValue;
+}
+
+// src/parseSchema.ts
+function parseSchema(schema, receivedValue) {
+  try {
+    return innerCheck(schema, receivedValue, "");
+  } catch (e) {
+    if (e instanceof ValidationError) throw e;
+    throw new Error("Something unexpected happened");
+  }
+}
+
+// src/asserts/number/max.ts
+var max = (expected) => (received, pathToError) => {
+  if (expected < received)
+    throwException(expected, received, pathToError, "The received value is greater than expected");
+};
+
+// src/asserts/number/maxExcluded.ts
+var maxExcluded = (expected) => (received, pathToError) => {
+  if (expected <= received)
+    throwException(expected, received, pathToError, "The received value is greater than or equal to expected");
+};
+
+// src/asserts/number/min.ts
+var min = (expected) => (received, pathToError) => {
+  if (expected > received)
+    throwException(expected, received, pathToError, "The received value is less than expected");
+};
+
+// src/asserts/number/minExcluded.ts
+var minExcluded = (expected) => (received, pathToError) => {
+  if (expected >= received)
+    throwException(expected, received, pathToError, "The received value is less than or equal to expected");
+};
+
+// src/asserts/number/positive.ts
+var positive = () => (received, pathToError) => {
+  if (received <= 0) throwException("positive", received, pathToError, "The received value is not a positive number");
+};
+
+// src/asserts/common/equalTo.ts
+var equalTo = (expected) => (received, pathToError) => {
+  if (expected !== received)
+    throwException(expected, received, pathToError, "The received value is not equal to expected");
+};
+
+// src/schemas/CommonSchema.ts
+var CommonSchema = class {
+  [ctxSymbol];
+  constructor(ctx) {
+    this[ctxSymbol] = ctx;
+  }
+  /**
+   * @param validators - One or more custom validation functions.
+   * @returns {this} The schema instance with the added custom validation.
+   */
+  custom(...validators) {
+    this[ctxSymbol].requiredValidations.push(...validators);
+    return this;
+  }
+  /**
+   * Marks the schema as nullable, allowing the value to be `null`.
+   *
+   * @returns {WithNull<this>} The schema instance marked as nullable.
+   */
+  nullable() {
+    this[ctxSymbol].isNullable = true;
+    return this;
+  }
+  /**
+   * Marks the schema as optional, allowing the value to be `undefined`.
+   *
+   * @returns {WithUndefined<this>}} The schema instance marked as optional.
+   */
+  optional() {
+    this[ctxSymbol].isOptional = true;
+    return this;
+  }
+};
+
+// src/schemas/NumberSchema.ts
+var NumberSchema = class extends CommonSchema {
+  _number = 1;
+  /**
+   * Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   *
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns - The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   *
+   * @example - number().equalTo(42); // Infers the type 42
+   */
+  equalTo(expectedValue) {
+    return this.custom(equalTo(expectedValue));
+  }
+};
+
+// src/asserts/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+
+// src/asserts/number/negative.ts
+var negative = () => (received, pathToError) => {
+  if (received >= 0) throwException("negative", received, pathToError, "The received value is not a negative number");
+};
+
+// src/__tests__/NumberSchema.test.ts
+describe("NumberSchema", () => {
+  it("should be a number", () => {
+    const numberSchema = number();
+    const actualNumber = 8;
+    const parsedValue = parseSchema(numberSchema, actualNumber);
+    expectEqualTypes(true);
+    expectEqualTypes(true);
+    expect(parsedValue).toBe(actualNumber);
+  });
+  it("should not be a number", () => {
+    const numberSchema = number();
+    const actualNotNumber = "9";
+    expectEqualTypes(false);
+    expect(() => parseSchema(numberSchema, actualNotNumber)).toThrow("Invalid type of data");
+  });
+  it("should be greater than or equal to 5", () => {
+    const numberSchema = number().custom(min(5));
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, 8)).toBe(8);
+    expect(parseSchema(numberSchema, 5)).toBe(5);
+    expect(() => parseSchema(numberSchema, 4)).toThrow("The received value is less than expected");
+  });
+  it("should be less than or equal to 5", () => {
+    const numberSchema = number().custom(max(5));
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, 2)).toBe(2);
+    expect(parseSchema(numberSchema, 5)).toBe(5);
+    expect(() => parseSchema(numberSchema, 9)).toThrow("The received value is greater than expected");
+  });
+  it("should be greater than 5", () => {
+    const numberSchema = number().custom(minExcluded(5));
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, 8)).toBe(8);
+    expect(() => parseSchema(numberSchema, 5)).toThrow("The received value is less than or equal to expected");
+    expect(() => parseSchema(numberSchema, 4)).toThrow("The received value is less than or equal to expected");
+  });
+  it("should be less than 5", () => {
+    const numberSchema = number().custom(maxExcluded(5));
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, 2)).toBe(2);
+    expect(() => parseSchema(numberSchema, 5)).toThrow("The received value is greater than or equal to expected");
+    expect(() => parseSchema(numberSchema, 9)).toThrow("The received value is greater than or equal to expected");
+  });
+  it("should be equal to be positive and equal to 5", () => {
+    const numberSchema = number().custom(positive()).equalTo(5);
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, 5)).toBe(5);
+    expect(() => parseSchema(numberSchema, 4)).toThrow("The received value is not equal to expected");
+    expect(() => parseSchema(numberSchema, 0)).toThrow("The received value is not a positive number");
+    expect(() => parseSchema(numberSchema, -1)).toThrow("The received value is not a positive number");
+  });
+  it("should be equal to be positive and equal to 5", () => {
+    const numberSchema = number().custom(negative()).equalTo(-2);
+    expectEqualTypes(true);
+    expect(parseSchema(numberSchema, -2)).toBe(-2);
+    expect(() => parseSchema(numberSchema, -1)).toThrow("The received value is not equal to expected");
+    expect(() => parseSchema(numberSchema, 0)).toThrow("The received value is not a negative number");
+    expect(() => parseSchema(numberSchema, 4)).toThrow("The received value is not a negative number");
+  });
+});
+//# sourceMappingURL=NumberSchema.test.js.map