@liminalfunctions/framework 1.0.0

package/src/utils/query_object_to_mongodb_query.ts

@@ -0,0 +1,73 @@
+import { QueryWithHelpers } from "mongoose";
+
+let complex_query_map = {
+    '_gt': '$gt',
+    '_lt': '$lt',
+    '_gte': '$gte',
+    '_lte': '$lte',
+    /*'_ne': '$ne',
+    '_starts_with': (key, value) => {
+        return new RegExp('^' + escapeRegExp(value))
+    },
+    '_ends_with': (key, value) => {
+        return new RegExp(escapeRegExp(value) + '$')
+    },*/
+    '_in': '$in'
+}
+
+let query_meta_map = {
+    'limit': true,
+    'cursor': true,
+    'sort': true,
+    'sort_order': true,
+    //'projection': true,
+}
+
+export function query_object_to_mongodb_query(query_object: any){
+    let retval = {} as any;
+
+    for(let [key, value] of Object.entries(query_object)){
+        if(Object.keys(query_meta_map).includes(key)){ continue; }
+        let complex_suffix = Object.keys(complex_query_map).find(ele => key.endsWith(ele)) as keyof typeof complex_query_map;
+        if (complex_suffix) {
+            let modified_key = key.slice(0, -complex_suffix.length);
+
+            if (!retval[modified_key]) { retval[modified_key] = {} as any; }
+            retval[modified_key][complex_query_map[complex_suffix]] = value;
+        } else {
+            retval[key] = value;
+        }
+    }
+
+    return retval;
+}
+
+export function query_object_to_mongodb_limits(query: QueryWithHelpers<any, any>, query_object: any, max_limit = 100) {
+    if (query_object.sort) {
+        let sort = {} as any;
+        sort[query_object.sort] = query_object.sort_order ? query_object.sort_order : 'ascending';
+        query.sort(sort)
+    }
+
+    if (query_object.sort_order && !query_object.sort) {
+        query.sort({ '_id': query_object.sort_order })
+    }
+
+    if (query_object.limit) {
+        query.limit(Math.min(Number.parseInt(query_object.limit), max_limit));
+    } else {
+        query.limit(max_limit);
+    }
+
+    if (query_object.cursor) {
+        if (query_object.sort === '_id' && query_object.sort_order === 'descending') {
+            query.sort({ '_id': 'descending' });
+            query.lt('_id', query_object.cursor);
+        } else {
+            query.sort({ '_id': 'ascending' });
+            query.gt('_id', query_object.cursor);
+        }
+    }
+
+    return query;
+} 

package/src/utils/query_validator_from_zod.ts

@@ -0,0 +1,246 @@
+import { z } from "zod/v4"
+import { $ZodLooseShape } from "zod/v4/core";
+import { magic_values, z_mongodb_id } from "./mongoose_from_zod.js";
+
+type type_filters = {
+    path: string,
+    filter: z.ZodType,
+    sortable: boolean,
+}[]
+type Mode = 'client' | 'server'
+
+export function query_validator_from_zod(zod_definition: z.ZodObject, mode: Mode = 'server'){
+    let retval = {
+        limit: z.coerce.number().int().optional(),
+        cursor: z_mongodb_id.optional(),
+        sort_order: z.enum([/*'asc', 'desc', */'ascending', 'descending']).optional()
+    } as $ZodLooseShape;
+    let object_filters = parse_object(zod_definition._zod.def, '', new Set(), mode);
+    for(let filter of object_filters){
+        retval[filter.path.slice(1)] = filter.filter;
+    }
+
+    retval.sort = z.enum(object_filters.filter(ele => ele.sortable).map(ele => ele.path.slice(1))).optional()
+
+    return z.object(retval).strict();
+}
+
+function parse_any(zod_definition: z.ZodTypeAny, prefix: string, loop_detector: Set<any> = new Set(), mode: Mode = 'server'): type_filters {
+    switch (zod_definition._zod.def.type) {
+        case "enum":
+            return parse_enum(zod_definition._zod.def as z.core.$ZodEnumDef, prefix, mode);
+        case "string":
+            return parse_string(prefix, mode);
+        case "number":
+        case "int":
+            return parse_number(prefix, mode);
+        case "object":
+            return parse_object(zod_definition._zod.def as z.core.$ZodObjectDef, prefix, loop_detector, mode);
+        case "boolean":
+            return parse_boolean(prefix, mode);
+        case "date":
+            return parse_date(prefix, mode);
+        case "array":
+            return parse_array(zod_definition._zod.def as z.core.$ZodArrayDef, prefix, loop_detector, mode)
+        case "union":
+            return parse_union(zod_definition._zod.def as z.core.$ZodUnionDef, prefix, mode)
+        case "custom":
+            if(!magic_values.has(zod_definition)) {
+                throw new Error(`could not find custom parser in the magic value dictionary`)
+            }
+            let { override_type } = magic_values.get(zod_definition);
+
+            if(override_type === 'mongodb_id'){
+                return parse_mongodb_id(prefix, mode);
+            } else {
+                throw new Error(`could not find custom parser for ${override_type} in the magic value dictionary`)
+            }
+        case "default":
+            //@ts-ignore
+            return parse_any((zod_definition._zod.def as z.core.$ZodDefaultDef).innerType, prefix, loop_detector, mode)
+        default:
+            return []
+    }
+}
+
+function parse_array(def: z.core.$ZodArrayDef, prefix: string, loop_detector: Set<any>, mode: Mode) {
+    let simple_children = ['enum', 'string', 'number', 'int', 'boolean']
+    if(simple_children.includes(def.element._zod.def.type)) {
+        //@ts-ignore
+        return parse_any(def.element, prefix, loop_detector, mode).filter(ele => ele.path == prefix)
+    } else if(def.element._zod.def.type === 'custom'){
+        if(!magic_values.has(def.element)) {
+            return [];
+        }
+        let { override_type } = magic_values.get(def.element);
+
+        if(override_type === 'mongodb_id'){
+            return parse_mongodb_id(prefix, mode).filter(ele => ele.path == prefix);
+        }
+    }
+    
+    return [];
+}
+
+function parse_object(def: z.core.$ZodObjectDef, prefix: string, loop_detector: Set<any>, mode: Mode): type_filters {
+    if(loop_detector.has(def)) {
+        return [];
+    }
+    loop_detector.add(def);
+
+    
+    let retval = [] as type_filters;
+    for(let [key, value] of Object.entries(def.shape)){
+        //@ts-ignore
+        let filters = parse_any(value, `${prefix}.${key}`, loop_detector, mode);
+        retval.push(...filters);
+    }
+    return retval;
+}
+
+function parse_union(def: z.core.$ZodUnionDef, prefix: string, mode: Mode): type_filters {
+    let simple_children = ['enum', 'string', 'number', 'int', 'boolean']
+    let filter_queue = def.options.slice().filter(ele => simple_children.includes(ele._zod.def.type));
+    let root = filter_queue.shift();
+    for(let filter of  filter_queue){
+        //@ts-expect-error
+        root = root.or(filter);
+    }
+    return [
+        {
+            path: prefix,
+            //@ts-expect-error
+            filter: root,
+            sortable: true,
+        }
+    ];
+}
+
+function parse_string(prefix: string, mode: Mode): type_filters {
+    let array_parser = mode === 'client' ? z.array(z.string()) : z.string().transform(val => val.split(',').filter(ele => ele.length > 0));
+    return [
+            {
+                path: prefix,
+                filter: z.string().optional(),
+                sortable: true,
+            },
+            {
+                path: prefix + '_gt',
+                filter: z.string().optional(),
+                sortable: false,
+            },
+            {
+                path: prefix + '_lt',
+                filter: z.string().optional(),
+                sortable: false,
+            },
+            {
+                path: prefix + '_in',
+                filter: array_parser.optional(),
+                sortable: false,
+            },
+        ];
+}
+
+function parse_enum(definition: z.core.$ZodEnumDef, prefix: string, mode: Mode): type_filters {
+    // TODO: figure out how to validate on the server such that it's a member of the enu,
+    let array_parser = mode === 'client' ? z.array(z.enum(definition.entries)) : z.string().transform(val => val.split(',').filter(ele => ele.length > 0));
+    return [
+            {
+                path: prefix,
+                filter: z.enum(definition.entries).optional(),
+                sortable: true,
+            },
+            {
+                path: prefix + '_in',
+                filter: array_parser.optional(),
+                sortable: false,
+            },
+        ];
+}
+
+function parse_boolean(prefix: string, mode: Mode): type_filters {
+    let boolean_parser = mode === 'client' ? z.boolean() : z.stringbool();
+    return [{
+        path: prefix,
+        filter: boolean_parser.optional(),
+        sortable: true,
+    }];
+}
+
+function parse_number(prefix: string, mode: Mode): type_filters {
+    let number_parser = mode === 'client' ? z.number() : z.coerce.number();
+    return [
+        {
+            path: prefix,
+            filter: number_parser.optional(),
+            sortable: true,
+        },
+        {
+            path: prefix + '_gt',
+            filter: number_parser.optional(),
+            sortable: false,
+        },
+        {
+            path: prefix + '_gte',
+            filter: number_parser.optional(),
+            sortable: false,
+        },
+        {
+            path: prefix + '_lt',
+            filter: number_parser.optional(),
+            sortable: false,
+        },
+        {
+            path: prefix + '_lte',
+            filter: number_parser.optional(),
+            sortable: false,
+        },
+    ];
+}
+
+function parse_date(prefix: string, mode: Mode): type_filters {
+    let date_parser = mode === 'client' ? z.date() : z.coerce.date();
+    return [{
+        path: prefix,
+        filter: date_parser.optional(),
+        sortable: true,
+    },
+    {
+        path: prefix + '_gt',
+        filter: date_parser.optional(),
+        sortable: false,
+    },
+    {
+        path: prefix + '_lt',
+        filter: date_parser.optional(),
+        sortable: false,
+    }];
+}
+
+
+function parse_mongodb_id(prefix: string, mode: Mode): type_filters {
+    let array_parser = mode === 'client' ? z.array(z_mongodb_id) :z.string().transform(val => val.split(',').filter(ele => ele.length > 0));
+    return [
+        {
+            path: prefix,
+            filter: z_mongodb_id.optional(),
+            sortable: true,
+        },
+        {
+            path: prefix + '_gt',
+            filter: z_mongodb_id.optional(),
+            sortable: false,
+        },
+        {
+            path: prefix + '_lt',
+            filter: z_mongodb_id.optional(),
+            sortable: false,
+        },
+        {
+            path: prefix + '_in',
+            filter: array_parser.optional(),
+            sortable: false,
+        },
+    ];
+}

package/test/0_0_mongoose_from_zod.test.ts

@@ -0,0 +1,260 @@
+import assert from "assert";
+import { z, ZodBoolean, ZodDate, ZodNumber, ZodString } from 'zod'
+
+import { schema_from_zod, z_mongodb_id } from '../dist/utils/mongoose_from_zod.js';
+import { Schema } from 'mongoose'
+import { required } from "zod/mini";
+
+describe('Mongoose from Zod', function () {
+
+    it('should convert an empty object', function () {
+        let zodSchema = z.object({ })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({}, mongooseSchema)
+    });
+
+    let basic_types = [{
+            label: 'string',
+            mongoose_type: String,
+            zod_function: z.string,
+            default_val: 'todd',
+        }, {
+            label: 'number',
+            mongoose_type: Number,
+            zod_function: z.number,
+            default_val: 42,
+        }, {
+            label: 'boolean',
+            mongoose_type: Boolean,
+            zod_function: z.boolean,
+            default_val: true,
+        }, {
+            label: 'date',
+            mongoose_type: Date,
+            zod_function: z.date,
+            default_val: new Date().toISOString(),
+        }, {
+            label: 'objectid',
+            mongoose_type: Schema.Types.ObjectId,
+            zod_function: () => z_mongodb_id,
+            default_val: '65add375755c5e0415b69803',
+        }
+    ]
+
+    /*
+        Basic type conversions
+    */
+    for(let basic_type of basic_types) {
+        it(`should convert ${basic_type.label} to mongoose type`, function () {
+            let zodSchema = z.object({ test_value: basic_type.zod_function() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: basic_type.mongoose_type, required: true } }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} to mongoose type with optional`, function () {
+            let zodSchema = z.object({ test_value: basic_type.zod_function().optional() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: basic_type.mongoose_type, required: false } }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} to mongoose type with default values`, function () {
+            //@ts-ignore
+            let zodSchema = z.object({ test_value: basic_type.zod_function().default(basic_type.default_val) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: basic_type.mongoose_type, required: true, default: basic_type.default_val } }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} to mongoose type with nullable`, function () {
+            let zodSchema = z.object({ test_value: basic_type.zod_function().nullable() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: basic_type.mongoose_type, required: true } }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} to mongoose type with optional AND default values`, function () {
+            //@ts-ignore
+            let zodSchema = z.object({ test_value: basic_type.zod_function().default(basic_type.default_val).optional() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: basic_type.mongoose_type, required: false, default: basic_type.default_val } }, mongooseSchema)
+        });
+    }
+
+    /*
+        nested type conversions
+    */
+    for(let basic_type of basic_types) {
+        it(`should convert a nested object containing a ${basic_type.label} property to mongoose type`, function () {
+            let zodSchema = z.object({ test_value: z.object({test_value: basic_type.zod_function() }) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: {test_value: { type: basic_type.mongoose_type, required: true }}, required: true} }, mongooseSchema)
+        });
+
+        it(`should convert a nested object containing a ${basic_type.label} property to mongoose type with optional`, function () {
+            let zodSchema = z.object({ test_value: z.object({test_value: basic_type.zod_function().optional() }) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: {test_value: { type: basic_type.mongoose_type, required: false }}, required: true } }, mongooseSchema)
+        });
+
+        it(`should convert a nested object containing a ${basic_type.label} property to mongoose type with default values`, function () {
+            //@ts-ignore
+            let zodSchema = z.object({ test_value: z.object({test_value: basic_type.zod_function().default(basic_type.default_val) }) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { type: {test_value: {  type: basic_type.mongoose_type, required: true, default: basic_type.default_val }}, required: true } }, mongooseSchema)
+        });
+    }
+
+    /*
+        array type conversions
+    */
+    for(let basic_type of basic_types) {
+        it(`should convert ${basic_type.label} array to mongoose type`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: true} }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} array to mongoose type with optional`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()).optional() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: false} }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} array to mongoose type with default values`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()).default([]) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: true, default: []} }, mongooseSchema)
+        });
+    }
+
+    /*
+        array inside an object conversions
+    */
+    for(let basic_type of basic_types) {
+        it(`should convert ${basic_type.label} array to mongoose type`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: true} }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} array to mongoose type with optional`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()).optional() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: false} }, mongooseSchema)
+        });
+
+        it(`should convert ${basic_type.label} array to mongoose type with default values`, function () {
+            let zodSchema = z.object({ test_value: z.array(basic_type.zod_function()).default([]) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: [{ type: basic_type.mongoose_type, required: true }], required: true, default: []} }, mongooseSchema)
+        });
+    }
+
+    /*
+        map conversions
+    */
+    for(let basic_type of basic_types) {
+        it(`should convert map of ${basic_type.label} to mongoose type`, function () {
+            let zodSchema = z.object({ test_value: z.map(z.string(), basic_type.zod_function()) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: Schema.Types.Map, of: { type: basic_type.mongoose_type, required: true }, required: true} }, mongooseSchema)
+        });
+
+        it(`should convert map of ${basic_type.label} to mongoose type with optional`, function () {
+            let zodSchema = z.object({ test_value: z.map(z.string(), basic_type.zod_function()).optional() })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: Schema.Types.Map, of: { type: basic_type.mongoose_type, required: true }, required: false} }, mongooseSchema)
+        });
+
+        it(`should convert map of ${basic_type.label} to mongoose type with default values`, function () {
+            //@ts-ignore
+            let zodSchema = z.object({ test_value: z.map(z.string(), basic_type.zod_function()).default({}) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: {type: Schema.Types.Map, of: { type: basic_type.mongoose_type, required: true }, required: true, default: {}} }, mongooseSchema)
+        });
+    }
+
+    /*
+        enum conversions
+    */
+
+    it(`should convert enums to mongoose type`, function () {
+        let zodSchema = z.object({ test_value: z.enum(['chunky', 'funky', 'monkey']) })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: String, required: true} }, mongooseSchema)
+    });
+
+    it(`should convert enums to mongoose type with optional`, function () {
+        let zodSchema = z.object({ test_value: z.enum(['chunky', 'funky', 'monkey']).optional() })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: String, required: false} }, mongooseSchema)
+    });
+
+    it(`should convert enums to mongoose type with default values`, function () {
+        let zodSchema = z.object({ test_value: z.enum(['chunky', 'funky', 'monkey']).default('chunky') })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: String, required: true, default: 'chunky'} }, mongooseSchema)
+    });
+
+    it(`should convert union types to a mixed schema`, function () {
+        let zodSchema = z.object({
+            test_value: z.number().or(z.string())
+        })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: Schema.Types.Mixed, required: true} }, mongooseSchema)
+    });
+
+    it(`should convert union types to a mixed schema with default values`, function () {
+        let zodSchema = z.object({
+            test_value: z.number().or(z.string()).default(2)
+        })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: Schema.Types.Mixed, required: true, default: 2} }, mongooseSchema)
+    });
+
+    it(`should convert union types to a mixed schema with optional`, function () {
+        let zodSchema = z.object({
+            test_value: z.number().or(z.string()).optional()
+        })
+        let mongooseSchema = schema_from_zod(zodSchema)
+        assert.deepEqual({ test_value: {type: Schema.Types.Mixed, required: false} }, mongooseSchema)
+    });
+
+    it(`should convert recursive schemas`, function () {
+        let zodSchema = z.object({
+            type: z.enum(['group']),
+            operator: z.enum(['all', 'any']),
+            get children() {
+                return z.array(zodSchema)
+            },
+            locked: z.boolean().optional()
+        })
+        let mongooseSchema = schema_from_zod(zodSchema)
+
+        assert.deepEqual({ 
+            type: {type: String, required: true },
+            operator: {type: String, required: true },
+            children: {type: [{ type: Schema.Types.Mixed, required: true }], required: true },
+            locked: {type: Boolean, required: false },
+        }, mongooseSchema)
+    })
+
+    it(`should not treat similar schemas as recursive`, function () {
+        let zodSchema = z.object({
+            a: z.object({
+                name: z.string()
+            }),
+            b: z.object({
+                name: z.string()
+            }),
+            c: z.object({
+                name: z.string()
+            }),
+        })
+        let mongooseSchema = schema_from_zod(zodSchema)
+
+        assert.deepEqual({ 
+            a: { type: { name: { type: String, required: true } }, required: true },
+            b: { type: { name: { type: String, required: true } }, required: true },
+            c: { type: { name: { type: String, required: true } }, required: true },
+        }, mongooseSchema)
+    })
+});