@fern-api/venus-api-sdk 0.10.0 → 0.10.1-2-g8c943d4

package/core/schemas/builders/literals/booleanLiteral.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanLiteral = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function booleanLiteral(literal) {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+        if (value === literal) {
+            return {
+                ok: true,
+                value: literal,
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, `${literal.toString()}`),
+                    },
+                ],
+            };
+        }
+    });
+    return schemaCreator();
+}
+exports.booleanLiteral = booleanLiteral;

package/core/schemas/builders/literals/index.d.ts

@@ -1 +1,2 @@
 export { stringLiteral } from "./stringLiteral";
+export { booleanLiteral } from "./booleanLiteral";

package/core/schemas/builders/literals/index.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringLiteral = void 0;
+exports.booleanLiteral = exports.stringLiteral = void 0;
 var stringLiteral_1 = require("./stringLiteral");
 Object.defineProperty(exports, "stringLiteral", { enumerable: true, get: function () { return stringLiteral_1.stringLiteral; } });
+var booleanLiteral_1 = require("./booleanLiteral");
+Object.defineProperty(exports, "booleanLiteral", { enumerable: true, get: function () { return booleanLiteral_1.booleanLiteral; } });

package/core/schemas/builders/literals/stringLiteral.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringLiteral = void 0;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 function stringLiteral(literal) {
-    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING_LITERAL, (value) => {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
         if (value === literal) {
             return {
                 ok: true,
@@ -16,8 +17,8 @@ function stringLiteral(literal) {
                 ok: false,
                 errors: [
                     {
-                        path: [],
-                        message: `Not equal to "${literal}"`,
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, `"${literal}"`),
                     },
                 ],
             };

package/core/schemas/builders/object/index.d.ts

@@ -1,3 +1,6 @@
 export { getObjectUtils, object } from "./object";
-export { isProperty, property, type Property } from "./property";
-export { type BaseObjectSchema, type inferObjectSchemaFromPropertySchemas, type inferParsedObject, type inferParsedObjectFromPropertySchemas, type inferParsedPropertySchema, type inferRawKey, type inferRawObject, type inferRawObjectFromPropertySchemas, type inferRawPropertySchema, type ObjectSchema, type ObjectUtils, type PropertySchemas, } from "./types";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
+export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
+export { isProperty, property } from "./property";
+export type { Property } from "./property";
+export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

package/core/schemas/builders/object/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.property = exports.isProperty = exports.object = exports.getObjectUtils = void 0;
+exports.property = exports.isProperty = exports.objectWithoutOptionalProperties = exports.object = exports.getObjectUtils = void 0;
 var object_1 = require("./object");
 Object.defineProperty(exports, "getObjectUtils", { enumerable: true, get: function () { return object_1.getObjectUtils; } });
 Object.defineProperty(exports, "object", { enumerable: true, get: function () { return object_1.object; } });
+var objectWithoutOptionalProperties_1 = require("./objectWithoutOptionalProperties");
+Object.defineProperty(exports, "objectWithoutOptionalProperties", { enumerable: true, get: function () { return objectWithoutOptionalProperties_1.objectWithoutOptionalProperties; } });
 var property_1 = require("./property");
 Object.defineProperty(exports, "isProperty", { enumerable: true, get: function () { return property_1.isProperty; } });
 Object.defineProperty(exports, "property", { enumerable: true, get: function () { return property_1.property; } });

package/core/schemas/builders/object/object.js

@@ -4,17 +4,19 @@ exports.getObjectUtils = exports.object = void 0;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const filterObject_1 = require("../../utils/filterObject");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const keys_1 = require("../../utils/keys");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const partition_1 = require("../../utils/partition");
 const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
 const property_1 = require("./property");
 function object(schemas) {
     const baseSchema = {
-        _getRawProperties: () => Promise.resolve(Object.entries(schemas).map(([parsedKey, propertySchema]) => (0, property_1.isProperty)(propertySchema) ? propertySchema.rawKey : parsedKey)),
-        _getParsedProperties: () => Promise.resolve((0, keys_1.keys)(schemas)),
-        parse: async (raw, opts) => {
+        _getRawProperties: () => Object.entries(schemas).map(([parsedKey, propertySchema]) => (0, property_1.isProperty)(propertySchema) ? propertySchema.rawKey : parsedKey),
+        _getParsedProperties: () => (0, keys_1.keys)(schemas),
+        parse: (raw, opts) => {
             const rawKeyToProperty = {};
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
@@ -28,7 +30,7 @@ function object(schemas) {
                     valueSchema,
                 };
                 rawKeyToProperty[rawKey] = property;
-                if (await isSchemaRequired(valueSchema)) {
+                if (isSchemaRequired(valueSchema)) {
                     requiredKeys.push(rawKey);
                 }
             }
@@ -42,19 +44,25 @@ function object(schemas) {
                     }
                     return {
                         transformedKey: property.parsedKey,
-                        transform: (propertyValue) => property.valueSchema.parse(propertyValue, opts),
+                        transform: (propertyValue) => {
+                            var _a;
+                            return property.valueSchema.parse(propertyValue, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), rawKey] }));
+                        },
                     };
                 },
-                allowUnknownKeys: opts?.allowUnknownKeys ?? false,
+                unrecognizedObjectKeys: opts === null || opts === void 0 ? void 0 : opts.unrecognizedObjectKeys,
+                skipValidation: opts === null || opts === void 0 ? void 0 : opts.skipValidation,
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+                omitUndefined: opts === null || opts === void 0 ? void 0 : opts.omitUndefined,
             });
         },
-        json: async (parsed, opts) => {
+        json: (parsed, opts) => {
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
                 const valueSchema = (0, property_1.isProperty)(schemaOrObjectProperty)
                     ? schemaOrObjectProperty.valueSchema
                     : schemaOrObjectProperty;
-                if (await isSchemaRequired(valueSchema)) {
+                if (isSchemaRequired(valueSchema)) {
                     requiredKeys.push(parsedKey);
                 }
             }
@@ -70,37 +78,41 @@ function object(schemas) {
                     if ((0, property_1.isProperty)(property)) {
                         return {
                             transformedKey: property.rawKey,
-                            transform: (propertyValue) => property.valueSchema.json(propertyValue, opts),
+                            transform: (propertyValue) => {
+                                var _a;
+                                return property.valueSchema.json(propertyValue, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), parsedKey] }));
+                            },
                         };
                     }
                     else {
                         return {
                             transformedKey: parsedKey,
-                            transform: (propertyValue) => property.json(propertyValue, opts),
+                            transform: (propertyValue) => {
+                                var _a;
+                                return property.json(propertyValue, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), parsedKey] }));
+                            },
                         };
                     }
                 },
-                allowUnknownKeys: opts?.allowUnknownKeys ?? false,
+                unrecognizedObjectKeys: opts === null || opts === void 0 ? void 0 : opts.unrecognizedObjectKeys,
+                skipValidation: opts === null || opts === void 0 ? void 0 : opts.skipValidation,
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+                omitUndefined: opts === null || opts === void 0 ? void 0 : opts.omitUndefined,
             });
         },
         getType: () => Schema_1.SchemaType.OBJECT,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-        ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
-        ...getObjectUtils(baseSchema),
-    };
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
 }
 exports.object = object;
-async function validateAndTransformObject({ value, requiredKeys, getProperty, allowUnknownKeys, }) {
+function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
             ok: false,
             errors: [
                 {
-                    path: [],
-                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
                 },
             ],
         };
@@ -112,34 +124,38 @@ async function validateAndTransformObject({ value, requiredKeys, getProperty, al
         const property = getProperty(preTransformedKey);
         if (property != null) {
             missingRequiredKeys.delete(preTransformedKey);
-            const value = await property.transform(preTransformedItemValue);
+            const value = property.transform(preTransformedItemValue);
             if (value.ok) {
                 transformed[property.transformedKey] = value.value;
             }
             else {
-                errors.push(...value.errors.map((error) => ({
-                    path: [preTransformedKey, ...error.path],
-                    message: error.message,
-                })));
+                transformed[preTransformedKey] = preTransformedItemValue;
+                errors.push(...value.errors);
             }
         }
-        else if (allowUnknownKeys) {
-            transformed[preTransformedKey] = preTransformedItemValue;
-        }
         else {
-            errors.push({
-                path: [preTransformedKey],
-                message: `Unrecognized key "${preTransformedKey}"`,
-            });
+            switch (unrecognizedObjectKeys) {
+                case "fail":
+                    errors.push({
+                        path: [...breadcrumbsPrefix, preTransformedKey],
+                        message: `Unexpected key "${preTransformedKey}"`,
+                    });
+                    break;
+                case "strip":
+                    break;
+                case "passthrough":
+                    transformed[preTransformedKey] = preTransformedItemValue;
+                    break;
+            }
         }
     }
     errors.push(...requiredKeys
         .filter((key) => missingRequiredKeys.has(key))
         .map((key) => ({
-        path: [],
+        path: breadcrumbsPrefix,
         message: `Missing required key "${key}"`,
     })));
-    if (errors.length === 0) {
+    if (errors.length === 0 || skipValidation) {
         return {
             ok: true,
             value: transformed,
@@ -156,25 +172,19 @@ function getObjectUtils(schema) {
     return {
         extend: (extension) => {
             const baseSchema = {
-                _getParsedProperties: async () => [
-                    ...(await schema._getParsedProperties()),
-                    ...(await extension._getParsedProperties()),
-                ],
-                _getRawProperties: async () => [
-                    ...(await schema._getRawProperties()),
-                    ...(await extension._getRawProperties()),
-                ],
-                parse: async (raw, opts) => {
+                _getParsedProperties: () => [...schema._getParsedProperties(), ...extension._getParsedProperties()],
+                _getRawProperties: () => [...schema._getRawProperties(), ...extension._getRawProperties()],
+                parse: (raw, opts) => {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: await extension._getRawProperties(),
+                        extensionKeys: extension._getRawProperties(),
                         value: raw,
                         transformBase: (rawBase) => schema.parse(rawBase, opts),
                         transformExtension: (rawExtension) => extension.parse(rawExtension, opts),
                     });
                 },
-                json: async (parsed, opts) => {
+                json: (parsed, opts) => {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: await extension._getParsedProperties(),
+                        extensionKeys: extension._getParsedProperties(),
                         value: parsed,
                         transformBase: (parsedBase) => schema.json(parsedBase, opts),
                         transformExtension: (parsedExtension) => extension.json(parsedExtension, opts),
@@ -182,28 +192,20 @@ function getObjectUtils(schema) {
                 },
                 getType: () => Schema_1.SchemaType.OBJECT,
             };
-            return {
-                ...baseSchema,
-                ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-                ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
-                ...getObjectUtils(baseSchema),
-            };
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
         },
     };
 }
 exports.getObjectUtils = getObjectUtils;
-async function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
+function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
     const extensionPropertiesSet = new Set(extensionKeys);
     const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
-    const transformedBase = await transformBase((0, filterObject_1.filterObject)(value, baseProperties));
-    const transformedExtension = await transformExtension((0, filterObject_1.filterObject)(value, extensionProperties));
+    const transformedBase = transformBase((0, filterObject_1.filterObject)(value, baseProperties));
+    const transformedExtension = transformExtension((0, filterObject_1.filterObject)(value, extensionProperties));
     if (transformedBase.ok && transformedExtension.ok) {
         return {
             ok: true,
-            value: {
-                ...transformedBase.value,
-                ...transformedExtension.value,
-            },
+            value: Object.assign(Object.assign({}, transformedBase.value), transformedExtension.value),
         };
     }
     else {
@@ -216,11 +218,11 @@ async function validateAndTransformExtendedObject({ extensionKeys, value, transf
         };
     }
 }
-async function isSchemaRequired(schema) {
-    return !(await isSchemaOptional(schema));
+function isSchemaRequired(schema) {
+    return !isSchemaOptional(schema);
 }
-async function isSchemaOptional(schema) {
-    switch (await schema.getType()) {
+function isSchemaOptional(schema) {
+    switch (schema.getType()) {
         case Schema_1.SchemaType.ANY:
         case Schema_1.SchemaType.UNKNOWN:
         case Schema_1.SchemaType.OPTIONAL:

package/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts

@@ -0,0 +1,6 @@
+import { inferParsedPropertySchema, inferRawObjectFromPropertySchemas, ObjectSchema, PropertySchemas } from "./types";
+export declare function objectWithoutOptionalProperties<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T>;
+export declare type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
+export declare type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {
+    [K in keyof T]: inferParsedPropertySchema<T[K]>;
+};

package/core/schemas/builders/object/objectWithoutOptionalProperties.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectWithoutOptionalProperties = void 0;
+const object_1 = require("./object");
+function objectWithoutOptionalProperties(schemas) {
+    return (0, object_1.object)(schemas);
+}
+exports.objectWithoutOptionalProperties = objectWithoutOptionalProperties;

package/core/schemas/builders/object/types.d.ts

@@ -5,8 +5,8 @@ import { SchemaUtils } from "../schema-utils";
 import { Property } from "./property";
 export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
-    _getRawProperties: () => Promise<(keyof Raw)[]>;
-    _getParsedProperties: () => Promise<(keyof Parsed)[]>;
+    _getRawProperties: () => (keyof Raw)[];
+    _getParsedProperties: () => (keyof Parsed)[];
 }
 export interface ObjectUtils<Raw, Parsed> {
     extend: <RawExtension, ParsedExtension>(schemas: ObjectSchema<RawExtension, ParsedExtension>) => ObjectSchema<Raw & RawExtension, Parsed & ParsedExtension>;

package/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withParsedProperties = exports.getObjectLikeUtils = void 0;
 const filterObject_1 = require("../../utils/filterObject");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
 const schema_utils_1 = require("../schema-utils");
 function getObjectLikeUtils(schema) {
@@ -15,33 +16,28 @@ exports.getObjectLikeUtils = getObjectLikeUtils;
  */
 function withParsedProperties(objectLike, properties) {
     const objectSchema = {
-        parse: async (raw, opts) => {
-            const parsedObject = await objectLike.parse(raw, opts);
+        parse: (raw, opts) => {
+            const parsedObject = objectLike.parse(raw, opts);
             if (!parsedObject.ok) {
                 return parsedObject;
             }
             const additionalProperties = Object.entries(properties).reduce((processed, [key, value]) => {
-                return {
-                    ...processed,
-                    [key]: typeof value === "function" ? value(parsedObject.value) : value,
-                };
+                return Object.assign(Object.assign({}, processed), { [key]: typeof value === "function" ? value(parsedObject.value) : value });
             }, {});
             return {
                 ok: true,
-                value: {
-                    ...parsedObject.value,
-                    ...additionalProperties,
-                },
+                value: Object.assign(Object.assign({}, parsedObject.value), additionalProperties),
             };
         },
         json: (parsed, opts) => {
+            var _a;
             if (!(0, isPlainObject_1.isPlainObject)(parsed)) {
                 return {
                     ok: false,
                     errors: [
                         {
-                            path: [],
-                            message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
+                            path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "object"),
                         },
                     ],
                 };
@@ -53,10 +49,6 @@ function withParsedProperties(objectLike, properties) {
         },
         getType: () => objectLike.getType(),
     };
-    return {
-        ...objectSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(objectSchema),
-        ...getObjectLikeUtils(objectSchema),
-    };
+    return Object.assign(Object.assign(Object.assign({}, objectSchema), (0, schema_utils_1.getSchemaUtils)(objectSchema)), getObjectLikeUtils(objectSchema));
 }
 exports.withParsedProperties = withParsedProperties;

package/core/schemas/builders/object-like/index.d.ts

@@ -1,2 +1,2 @@
 export { getObjectLikeUtils, withParsedProperties } from "./getObjectLikeUtils";
-export { type ObjectLikeSchema, type ObjectLikeUtils } from "./types";
+export type { ObjectLikeSchema, ObjectLikeUtils } from "./types";

package/core/schemas/builders/primitives/boolean.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.boolean = void 0;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
-exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN, (value) => {
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN, (value, { breadcrumbsPrefix = [] } = {}) => {
     if (typeof value === "boolean") {
         return {
             ok: true,
@@ -15,8 +16,8 @@ exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)
             ok: false,
             errors: [
                 {
-                    path: [],
-                    message: "Not a boolean",
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "boolean"),
                 },
             ],
         };

package/core/schemas/builders/primitives/number.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.number = void 0;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
-exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.NUMBER, (value) => {
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.NUMBER, (value, { breadcrumbsPrefix = [] } = {}) => {
     if (typeof value === "number") {
         return {
             ok: true,
@@ -15,8 +16,8 @@ exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(
             ok: false,
             errors: [
                 {
-                    path: [],
-                    message: "Not a number",
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "number"),
                 },
             ],
         };

package/core/schemas/builders/primitives/string.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.string = void 0;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
-exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING, (value) => {
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING, (value, { breadcrumbsPrefix = [] } = {}) => {
     if (typeof value === "string") {
         return {
             ok: true,
@@ -15,8 +16,8 @@ exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(
             ok: false,
             errors: [
                 {
-                    path: [],
-                    message: "Not a string",
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "string"),
                 },
             ],
         };

package/core/schemas/builders/record/index.d.ts

@@ -1,2 +1,2 @@
 export { record } from "./record";
-export { type BaseRecordSchema, type RecordSchema } from "./types";
+export type { BaseRecordSchema, RecordSchema } from "./types";

package/core/schemas/builders/record/record.js

@@ -3,52 +3,65 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.record = void 0;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function record(keySchema, valueSchema) {
     const baseSchema = {
-        parse: async (raw, opts) => {
+        parse: (raw, opts) => {
             return validateAndTransformRecord({
                 value: raw,
-                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
-                transformKey: (key) => keySchema.parse(key, opts),
-                transformValue: (value) => valueSchema.parse(value, opts),
+                isKeyNumeric: keySchema.getType() === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.parse(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
         },
-        json: async (parsed, opts) => {
+        json: (parsed, opts) => {
             return validateAndTransformRecord({
                 value: parsed,
-                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
-                transformKey: (key) => keySchema.json(key, opts),
-                transformValue: (value) => valueSchema.json(value, opts),
+                isKeyNumeric: keySchema.getType() === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.json(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
         },
         getType: () => Schema_1.SchemaType.RECORD,
     };
-    return {
-        ...baseSchema,
-        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
-    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
 exports.record = record;
-async function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, }) {
+function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
             ok: false,
             errors: [
                 {
-                    path: [],
-                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
                 },
             ],
         };
     }
-    return (0, entries_1.entries)(value).reduce(async (accPromise, [stringKey, value]) => {
+    return (0, entries_1.entries)(value).reduce((accPromise, [stringKey, value]) => {
         // skip nullish keys
         if (value == null) {
             return accPromise;
         }
-        const acc = await accPromise;
+        const acc = accPromise;
         let key = stringKey;
         if (isKeyNumeric) {
             const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
@@ -56,15 +69,12 @@ async function validateAndTransformRecord({ value, isKeyNumeric, transformKey, t
                 key = numberKey;
             }
         }
-        const transformedKey = await transformKey(key);
-        const transformedValue = await transformValue(value);
+        const transformedKey = transformKey(key);
+        const transformedValue = transformValue(value, key);
         if (acc.ok && transformedKey.ok && transformedValue.ok) {
             return {
                 ok: true,
-                value: {
-                    ...acc.value,
-                    [transformedKey.value]: transformedValue.value,
-                },
+                value: Object.assign(Object.assign({}, acc.value), { [transformedKey.value]: transformedValue.value }),
             };
         }
         const errors = [];
@@ -72,20 +82,14 @@ async function validateAndTransformRecord({ value, isKeyNumeric, transformKey, t
             errors.push(...acc.errors);
         }
         if (!transformedKey.ok) {
-            errors.push(...transformedKey.errors.map((error) => ({
-                path: [`${key} (key)`, ...error.path],
-                message: error.message,
-            })));
+            errors.push(...transformedKey.errors);
         }
         if (!transformedValue.ok) {
-            errors.push(...transformedValue.errors.map((error) => ({
-                path: [stringKey, ...error.path],
-                message: error.message,
-            })));
+            errors.push(...transformedValue.errors);
         }
         return {
             ok: false,
             errors,
         };
-    }, Promise.resolve({ ok: true, value: {} }));
+    }, { ok: true, value: {} });
 }