vellum-ai 0.0.45 → 0.1.1

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

@@ -1,11 +1,22 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
@@ -14,7 +25,7 @@ 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) => {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
             const rawKeyToProperty = {};
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
@@ -28,7 +39,7 @@ function object(schemas) {
                     valueSchema,
                 };
                 rawKeyToProperty[rawKey] = property;
-                if (await isSchemaRequired(valueSchema)) {
+                if (yield isSchemaRequired(valueSchema)) {
                     requiredKeys.push(rawKey);
                 }
             }
@@ -42,19 +53,24 @@ 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] }));
+                        },
                     };
                 },
-                unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+                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,
             });
-        },
-        json: async (parsed, opts) => {
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
             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 (yield isSchemaRequired(valueSchema)) {
                     requiredKeys.push(parsedKey);
                 }
             }
@@ -70,168 +86,173 @@ 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] }));
+                            },
                         };
                     }
                 },
-                unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+                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,
             });
-        },
+        }),
         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, unrecognizedObjectKeys = "fail", }) {
-    if (!(0, isPlainObject_1.isPlainObject)(value)) {
-        return {
-            ok: false,
-            errors: [
-                {
-                    path: [],
-                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
-                },
-            ],
-        };
-    }
-    const missingRequiredKeys = new Set(requiredKeys);
-    const errors = [];
-    const transformed = {};
-    for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
-        const property = getProperty(preTransformedKey);
-        if (property != null) {
-            missingRequiredKeys.delete(preTransformedKey);
-            const value = await property.transform(preTransformedItemValue);
-            if (value.ok) {
-                transformed[property.transformedKey] = value.value;
+function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, isPlainObject_1.isPlainObject)(value)) {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
+                    },
+                ],
+            };
+        }
+        const missingRequiredKeys = new Set(requiredKeys);
+        const errors = [];
+        const transformed = {};
+        for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
+            const property = getProperty(preTransformedKey);
+            if (property != null) {
+                missingRequiredKeys.delete(preTransformedKey);
+                const value = yield property.transform(preTransformedItemValue);
+                if (value.ok) {
+                    transformed[property.transformedKey] = value.value;
+                }
+                else {
+                    transformed[preTransformedKey] = preTransformedItemValue;
+                    errors.push(...value.errors);
+                }
             }
             else {
-                errors.push(...value.errors.map((error) => ({
-                    path: [preTransformedKey, ...error.path],
-                    message: error.message,
-                })));
+                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: breadcrumbsPrefix,
+            message: `Missing required key "${key}"`,
+        })));
+        if (errors.length === 0 || skipValidation) {
+            return {
+                ok: true,
+                value: transformed,
+            };
+        }
         else {
-            switch (unrecognizedObjectKeys) {
-                case "fail":
-                    errors.push({
-                        path: [preTransformedKey],
-                        message: `Unrecognized key "${preTransformedKey}"`,
-                    });
-                    break;
-                case "strip":
-                    break;
-                case "passthrough":
-                    transformed[preTransformedKey] = preTransformedItemValue;
-                    break;
-            }
+            return {
+                ok: false,
+                errors,
+            };
         }
-    }
-    errors.push(...requiredKeys
-        .filter((key) => missingRequiredKeys.has(key))
-        .map((key) => ({
-        path: [],
-        message: `Missing required key "${key}"`,
-    })));
-    if (errors.length === 0) {
-        return {
-            ok: true,
-            value: transformed,
-        };
-    }
-    else {
-        return {
-            ok: false,
-            errors,
-        };
-    }
+    });
 }
 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: () => __awaiter(this, void 0, void 0, function* () {
+                    return [
+                        ...(yield schema._getParsedProperties()),
+                        ...(yield extension._getParsedProperties()),
+                    ];
+                }),
+                _getRawProperties: () => __awaiter(this, void 0, void 0, function* () {
+                    return [
+                        ...(yield schema._getRawProperties()),
+                        ...(yield extension._getRawProperties()),
+                    ];
+                }),
+                parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: await extension._getRawProperties(),
+                        extensionKeys: yield extension._getRawProperties(),
                         value: raw,
                         transformBase: (rawBase) => schema.parse(rawBase, opts),
                         transformExtension: (rawExtension) => extension.parse(rawExtension, opts),
                     });
-                },
-                json: async (parsed, opts) => {
+                }),
+                json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: await extension._getParsedProperties(),
+                        extensionKeys: yield extension._getParsedProperties(),
                         value: parsed,
                         transformBase: (parsedBase) => schema.json(parsedBase, opts),
                         transformExtension: (parsedExtension) => extension.json(parsedExtension, opts),
                     });
-                },
+                }),
                 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, }) {
-    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));
-    if (transformedBase.ok && transformedExtension.ok) {
-        return {
-            ok: true,
-            value: {
-                ...transformedBase.value,
-                ...transformedExtension.value,
-            },
-        };
-    }
-    else {
-        return {
-            ok: false,
-            errors: [
-                ...(transformedBase.ok ? [] : transformedBase.errors),
-                ...(transformedExtension.ok ? [] : transformedExtension.errors),
-            ],
-        };
-    }
+function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const extensionPropertiesSet = new Set(extensionKeys);
+        const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
+        const transformedBase = yield transformBase((0, filterObject_1.filterObject)(value, baseProperties));
+        const transformedExtension = yield transformExtension((0, filterObject_1.filterObject)(value, extensionProperties));
+        if (transformedBase.ok && transformedExtension.ok) {
+            return {
+                ok: true,
+                value: Object.assign(Object.assign({}, transformedBase.value), transformedExtension.value),
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    ...(transformedBase.ok ? [] : transformedBase.errors),
+                    ...(transformedExtension.ok ? [] : transformedExtension.errors),
+                ],
+            };
+        }
+    });
 }
-async function isSchemaRequired(schema) {
-    return !(await isSchemaOptional(schema));
+function isSchemaRequired(schema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return !(yield isSchemaOptional(schema));
+    });
 }
-async function isSchemaOptional(schema) {
-    switch (await schema.getType()) {
-        case Schema_1.SchemaType.ANY:
-        case Schema_1.SchemaType.UNKNOWN:
-        case Schema_1.SchemaType.OPTIONAL:
-            return true;
-        default:
-            return false;
-    }
+function isSchemaOptional(schema) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (yield schema.getType()) {
+            case Schema_1.SchemaType.ANY:
+            case Schema_1.SchemaType.UNKNOWN:
+            case Schema_1.SchemaType.OPTIONAL:
+                return true;
+            default:
+                return false;
+        }
+    });
 }

package/dist/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/dist/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/dist/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -1,7 +1,17 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 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 +25,28 @@ exports.getObjectLikeUtils = getObjectLikeUtils;
  */
 function withParsedProperties(objectLike, properties) {
     const objectSchema = {
-        parse: async (raw, opts) => {
-            const parsedObject = await objectLike.parse(raw, opts);
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsedObject = yield 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 +58,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/dist/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/dist/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/dist/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/dist/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/dist/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";