@wener/common 1.0.5 → 2.0.1

package/lib/schema/toJsonSchema.js

@@ -0,0 +1,441 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function (key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function (sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    }
+    else {
+        ownKeys(Object(source)).forEach(function (key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { omit, remove } from "es-toolkit";
+import { match, P } from "ts-pattern";
+import { z } from "zod/v4";
+import { getSchemaCache } from "./getSchemaCache.js";
+import { isTypeBoxSchema, isZodSchema } from "./validate.js";
+export function toJsonSchema(schema) {
+    if (isZodSchema(schema)) {
+        return getSchemaCache(schema, "jsonschema", function () {
+            // zod v4
+            var js = z.toJSONSchema(schema, {
+                unrepresentable: "any",
+                override: function (param) {
+                    var zodSchema = param.zodSchema, js = param.jsonSchema;
+                    var def = zodSchema._zod.def;
+                    var meta = z.globalRegistry.get(zodSchema);
+                    if (meta) {
+                        Object.assign(js, meta);
+                    }
+                    switch (def.type) {
+                        case "union":
+                            if (zodSchema._zod.traits.has("ZodDiscriminatedUnion")) {
+                                resolveDiscriminator(js);
+                            }
+                            break;
+                        case "nonoptional":
+                            // js._ref maybe true
+                            js.nullable = false;
+                            break;
+                        case "nullable":
+                        case "optional":
+                            // prefer nullable
+                            match(js).with({
+                                anyOf: [
+                                    P.select(),
+                                    {
+                                        type: "null"
+                                    }
+                                ]
+                            }, function (select) {
+                                delete js["anyOf"];
+                                Object.assign(js, select);
+                                js.nullable = true;
+                            }).otherwise(function (js) {
+                                js.nullable = true;
+                            });
+                            break;
+                    }
+                }
+            });
+            // remove redundant nullable, ensure required is sorted
+            visit(js, function (v) {
+                if (v.nullable === false) {
+                    delete v.nullable;
+                }
+                if (v.required) {
+                    v.required.sort();
+                }
+            });
+            // maybe freeze
+            return js;
+        });
+    }
+    if (isTypeBoxSchema(schema)) {
+        return schema;
+    }
+    return schema;
+}
+function visit(js, f) {
+    var _visit = function (js, f, parent, path, k) {
+        if (!js) {
+            return;
+        }
+        f(js);
+        if (js.properties) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for (var _iterator = Object.entries(js.properties)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var _step_value = _sliced_to_array(_step.value, 2), k1 = _step_value[0], v = _step_value[1];
+                    if (v) {
+                        _visit(v, f, js, path.concat(k1), "properties");
+                    }
+                }
+            }
+            catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        else if (js.items) {
+            if (Array.isArray(js.items)) {
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for (var _iterator1 = js.items[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                        var v1 = _step1.value;
+                        _visit(v1, f, js, path, "items");
+                    }
+                }
+                catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                }
+                finally {
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    }
+                    finally {
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+            else {
+                _visit(js.items, f, js, path, "items");
+            }
+        }
+        else if (js.anyOf) {
+            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+            try {
+                for (var _iterator2 = js.anyOf[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                    var v2 = _step2.value;
+                    _visit(v2, f, js, path, "anyOf");
+                }
+            }
+            catch (err) {
+                _didIteratorError2 = true;
+                _iteratorError2 = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                        _iterator2.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError2) {
+                        throw _iteratorError2;
+                    }
+                }
+            }
+        }
+        else if (js.oneOf) {
+            var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+            try {
+                for (var _iterator3 = js.oneOf[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                    var v3 = _step3.value;
+                    _visit(v3, f, js, path, "oneOf");
+                }
+            }
+            catch (err) {
+                _didIteratorError3 = true;
+                _iteratorError3 = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                        _iterator3.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError3) {
+                        throw _iteratorError3;
+                    }
+                }
+            }
+        }
+        else if (js.allOf) {
+            var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+            try {
+                for (var _iterator4 = js.allOf[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                    var v4 = _step4.value;
+                    _visit(v4, f, js, path, "allOf");
+                }
+            }
+            catch (err) {
+                _didIteratorError4 = true;
+                _iteratorError4 = err;
+            }
+            finally {
+                try {
+                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                        _iterator4.return();
+                    }
+                }
+                finally {
+                    if (_didIteratorError4) {
+                        throw _iteratorError4;
+                    }
+                }
+            }
+        }
+    };
+    _visit(js, f, undefined, []);
+}
+function resolveJsonSchemaDef(js, ctx) {
+    return match(js).with({
+        anyOf: [
+            P.select(),
+            {
+                type: "null"
+            }
+        ]
+    }, function (select) {
+        return _object_spread_props(_object_spread({}, omit(js, [
+            "anyOf"
+        ]), select), {
+            nullable: true
+        });
+    }).with({
+        properties: P.nonNullable
+    }, function (schema) {
+        for (var key in schema.properties) {
+            var prop = schema.properties[key];
+            if (prop) {
+                schema.properties[key] = resolveJsonSchemaDef(prop, {
+                    parent: schema,
+                    key: key
+                });
+            }
+        }
+        return schema;
+    }).otherwise(function () {
+        return js;
+    });
+}
+function resolveDiscriminator(jsd) {
+    if (!(jsd.anyOf && jsd.anyOf.length > 1)) {
+        return;
+    }
+    if (jsd.discriminator) {
+        return;
+    }
+    var names = [];
+    {
+        // candidate for discriminator
+        var v = jsd.anyOf[0];
+        if (v && v.type === "object" && v.properties) {
+            if (Array.isArray(v.required)) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for (var _iterator = v.required[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                        var k = _step.value;
+                        if (v.properties[k].const !== undefined) {
+                            names.push(k);
+                        }
+                    }
+                }
+                catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                }
+                finally {
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    }
+                    finally {
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (names.length >= 1) {
+        var _loop = function (i) {
+            if (i === 0) {
+                // skip first
+                return "continue";
+            }
+            if (!names.length) {
+                return "break";
+            }
+            var v = jsd.anyOf[i];
+            if (v && v.type === "object" && v.properties) {
+                var props = v.properties;
+                remove(names, function (k) {
+                    // dont care the mapping
+                    var p = props[k];
+                    switch (_type_of(p.const)) {
+                        case "string":
+                        case "number":
+                        case "boolean":
+                            return false;
+                        default:
+                            return true;
+                    }
+                });
+            }
+            else {
+                names = [];
+                return "break";
+            }
+        };
+        for (var i = 0; i < jsd.anyOf.length; i++) {
+            var _ret = _loop(i);
+            if (_ret === "break")
+                break;
+        }
+    }
+    if (names.length === 1) {
+        jsd.discriminator = {
+            propertyName: names[0]
+        };
+    }
+}

package/lib/schema/toJsonSchema.test.js

@@ -0,0 +1,27 @@
+import { inspect } from "node:util";
+import { describe, expect, it } from "vitest";
+import { z } from "zod/v4";
+import { toJsonSchema } from "./toJsonSchema.js";
+describe("toJsonSchema", function () {
+    it("should handle discriminatedUnion", function () {
+        console.log(inspect(toJsonSchema(z.discriminatedUnion("type", [
+            z.object({
+                type: z.literal("string"),
+                value: z.string()
+            }),
+            z.object({
+                type: z.literal("number"),
+                value: z.number()
+            })
+        ])), {
+            depth: 10,
+            colors: true
+        }));
+    });
+    it("should cache", function () {
+        var zs = z.object({
+            name: z.string()
+        });
+        expect(toJsonSchema(zs)).toBe(toJsonSchema(zs));
+    });
+});

package/lib/schema/validate.js

@@ -0,0 +1,124 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { Kind as TypeBoxKind } from '@sinclair/typebox';
+import '@sinclair/typebox';
+import { TypeCompiler } from '@sinclair/typebox/compiler';
+import { ifPresent } from '@wener/utils';
+import { Ajv } from 'ajv';
+import addFormats from 'ajv-formats';
+/*
+https://github.com/react-hook-form/resolvers
+https://github.com/decs/typeschema/tree/main/packages
+*/ export function validate(schema, data) {
+    if (isZodSchema(schema)) {
+        var result = schema.safeParse(data);
+        if (result.success) {
+            return {
+                success: true,
+                data: result.data
+            };
+        }
+        return {
+            issues: result.error.issues.map(function(param) {
+                var message = param.message, path = param.path, code = param.code;
+                return {
+                    message: message,
+                    path: path,
+                    code: code
+                };
+            }),
+            // message: z.prettifyError(result.error),
+            success: false
+        };
+    }
+    if (isTypeBoxSchema(schema)) {
+        var checker = TypeCompiler.Compile(schema);
+        if (checker.Check(data)) {
+            return {
+                success: true,
+                data: data
+            };
+        }
+        return {
+            issues: Array.from(checker.Errors(data)).map(function(param) {
+                var message = param.message, path = param.path;
+                return {
+                    message: message,
+                    path: [
+                        path
+                    ]
+                };
+            }),
+            // message: '',
+            success: false
+        };
+    }
+    if (isJsonSchema(schema)) {
+        var _validator_errors;
+        var ajv = new Ajv({
+            allErrors: true,
+            validateSchema: true
+        });
+        addFormats(ajv);
+        var validator = ajv.compile(schema);
+        if (validator(data)) {
+            return {
+                data: data,
+                success: true
+            };
+        }
+        var issues = ((_validator_errors = validator.errors) === null || _validator_errors === void 0 ? void 0 : _validator_errors.map(function(error) {
+            var message = error.message || 'Unknown error';
+            var path = error.instancePath.split('/').filter(Boolean).map(function(p) {
+                return p;
+            });
+            return {
+                message: message,
+                path: path
+            };
+        })) || [];
+        return {
+            success: false,
+            // message: 'Invalid data',
+            issues: issues
+        };
+    }
+    return {
+        success: false,
+        // message: 'Invalid schema',
+        issues: [
+            {
+                message: 'Unknown schema type'
+            }
+        ]
+    };
+}
+export function parseData(schema, data) {
+    var result = validate(schema, data);
+    if (result.success) {
+        return result.data;
+    }
+    throw Object.assign(new Error(result.issues.map(function(v) {
+        var _v_path;
+        return "".concat(ifPresent((_v_path = v.path) === null || _v_path === void 0 ? void 0 : _v_path.join(), function(v) {
+            return "[".concat(v, "]");
+        }), ": ").concat(v.message);
+    }).join('; ')), {
+        issues: result.issues
+    });
+}
+function formatIssues(schema, issues) {
+    return '';
+}
+export function isZodSchema(schema) {
+    return (typeof schema === "undefined" ? "undefined" : _type_of(schema)) === 'object' && 'parse' in schema;
+}
+export function isTypeBoxSchema(schema) {
+    return (typeof schema === "undefined" ? "undefined" : _type_of(schema)) === 'object' && TypeBoxKind in schema;
+}
+export function isJsonSchema(schema) {
+    var sc = schema;
+    return (typeof schema === "undefined" ? "undefined" : _type_of(schema)) === 'object' && Boolean(sc.type || sc.properties || sc.anyOf || sc.oneOf || sc.$ref || sc.items);
+}

package/lib/search/AdvanceSearch.js

@@ -7,4 +7,3 @@ import { parseAdvanceSearch } from "./parseAdvanceSearch.js";
     AdvanceSearch.optimize = optimizeAdvanceSearch;
 })(AdvanceSearch || (AdvanceSearch = {}));
 export var AdvanceSearch;
-//# sourceMappingURL=AdvanceSearch.js.map