@liminalfunctions/framework 1.0.67 → 1.0.69

package/dist/utils/zod_loop_seperator.js.map

@@ -1 +1 @@
-{"version":3,"file":"zod_loop_seperator.js","sourceRoot":"","sources":["../../src/utils/zod_loop_seperator.ts"],"names":[],"mappings":"AAWA,MAAM,UAAU,kBAAkB,CAAC,SAAc;IAC7C,OAAO,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,IAAI,SAAS,CAAC,SAAS,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,cAAyB;IAChD,IAAI,eAAe,GAAG,cAAc,CAAC,cAAc,CAAC,CAAC;IACrD,KAAI,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,eAAe,CAAC,OAAO,EAAE,EAAC,CAAC;QAC/C,IAAG,KAAK,CAAC,WAAW,IAAI,CAAC,EAAC,CAAC;YAAC,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAAC,CAAC;IAC9D,CAAC;IACD,OAAO,eAAe,CAAC;AAC3B,CAAC;AAED,SAAS,cAAc,CACnB,cAAyB,EACzB,mBAA8C,IAAI,GAAG,EAAE;IACvD,IAAG,CAAC,cAAc,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvB,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IAClC,CAAC;IAED,QAAQ,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACnC,KAAK,QAAQ;YACT,YAAY,CAAC,cAA6B,EAAG,gBAAgB,CAAC,CAAC;YAC/D,MAAM;QACV,KAAK,OAAO;YAER,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;YAClE,MAAM;QACV,KAAK,UAAU,CAAC;QAChB,KAAK,UAAU,CAAC;QAChB,KAAK,SAAS;YAEV,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;YACpE,MAAM;QACX,KAAK,QAAQ;YACR,YAAY,CAAC,cAAc,CAAC,IAAI,CAAC,GAA2B,EAAE,gBAAgB,CAAC,CAAC;YAChF,MAAM;QACV,KAAK,OAAO;YACR,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,GAA0B,EAAE,gBAAgB,CAAC,CAAC;YAC9E,MAAM;QACV;YACI,MAAM;IACd,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC5B,CAAC;AAED,SAAS,YAAY,CAAC,gBAA6B,EAAE,gBAA2C;IAC5F,IAAI,GAAG,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC;IACpC,IAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;QACxC,OAAO;IACX,CAAC;IACD,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE;QACtB,WAAW,EAAE,CAAC;QACd,MAAM,EAAE,EAAE;QACV,SAAS,EAAE,gBAAgB;QAE3B,GAAG,EAAE,GAAG;QACR,IAAI,EAAE,EAAE;KACX,CAAC,CAAA;IACF,KAAI,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAC,CAAC;QAE/C,cAAc,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;IAC5C,CAAC;AACL,CAAC;AAED,SAAS,YAAY,CAAC,GAAyB,EAAE,gBAA2C;IAExF,cAAc,CAAC,GAAG,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;IAG9C,cAAc,CAAC,GAAG,CAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,WAAW,CAAC,GAAwB,EAAE,gBAA2C;IACtF,KAAI,IAAI,MAAM,IAAI,GAAG,CAAC,OAAO,EAAC,CAAC;QAE3B,cAAc,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,CAAC;AACL,CAAC"}
+{"version":3,"file":"zod_loop_seperator.js","sourceRoot":"","sources":["../../src/utils/zod_loop_seperator.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liminalfunctions/framework",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "main": "./dist/index.js",
   "type": "module",
   "scripts": {
@@ -28,12 +28,12 @@
     "@types/mocha": "^10.0.10",
     "@types/mustache": "^4.2.6",
     "@types/node": "^22.10.7",
+    "got": "^14.6.0",
     "mocha": "^11.1.0",
     "rimraf": "^6.0.1",
     "tsx": "^4.19.3",
     "typescript": "^5.7.3",
-    "zod": "^4.0.17",
-    "got": "^14.6.0"
+    "zod": "^4.0.17"
   },
   "peerDependencies": {
     "express": "^5.1.0",
@@ -43,6 +43,7 @@
   },
   "dependencies": {
     "copyfiles": "^2.4.1",
+    "escape-string-regexp": "^5.0.0",
     "mustache": "^4.2.0"
   }
 }

package/src/F_Collection.ts

@@ -4,6 +4,7 @@ import mongoose, { Collection, Model, ObjectId } from "mongoose";
 import { F_Security_Model } from "./F_Security_Models/F_Security_Model.js";
 import { query_validator_from_zod } from "./utils/query_validator_from_zod.js";
 import { array_children_from_zod } from "./utils/array_children_from_zod.js";
+import { complex_query_validator_from_zod } from "./utils/complex_query_validator_from_zod.js";
 
 export type CollectionType<Col extends F_Collection<string, Validator>, Validator extends z.ZodObject> = z.output<Col['validator']>;
 
@@ -24,6 +25,8 @@ export class F_Collection<Collection_ID extends string, ZodSchema extends z.ZodO
     
     query_validator_server: z.ZodType;
     query_validator_client: z.ZodType;
+    advanced_query_validator_server: z.ZodType;
+    advanced_query_validator_client: z.ZodType;
     put_validator: ReturnType<ZodSchema['partial']>;
     // TODO: Come back and find a way to select the particular partial I want
     // instead of partialing the whole object.
@@ -49,6 +52,8 @@ export class F_Collection<Collection_ID extends string, ZodSchema extends z.ZodO
         this.mongoose_model = mongoose_from_zod(collection_name, validator, database);
         this.query_validator_server = query_validator_from_zod(validator, 'server');
         this.query_validator_client = query_validator_from_zod(validator, 'client');
+        this.advanced_query_validator_server = complex_query_validator_from_zod(validator, 'server').optional()
+        this.advanced_query_validator_client = complex_query_validator_from_zod(validator, 'client').optional()
         // TODO: we can make this more closely match the mongoDB PUT operation and allow updates to eg array.3.element fields
 
         if(!Object.hasOwn(this.validator._zod.def.shape, '_id')){

package/src/F_Compile.ts

@@ -127,6 +127,7 @@ export function compile<Collection_ID extends string, ZodSchema extends z.ZodObj
             try {
                 validated_query_args = collection.query_validator_server.parse(convert_null(req.query));
             } catch(err){
+                console.log(err.issues)
                 if(err instanceof z.ZodError){
                     res.status(400);
                     res.json({ error: err.issues });
@@ -150,6 +151,23 @@ export function compile<Collection_ID extends string, ZodSchema extends z.ZodObj
                 res.json({ error: `You do not have permission to fetch documents from ${collection.collection_id}.` });
                 return;
             }
+
+            if(validated_query_args.advanced_query){
+                let parsed_advanced_query: unknown;
+                try { parsed_advanced_query = JSON.parse(validated_query_args.advanced_query); } catch(err) {
+                    res.status(400);
+                    res.json({ error: `The advanced_query field was not in JSON format` });
+                    return
+                }
+                let { data: advanced_query, error: parsed_advanced_query_error, success: parsed_advanced_query_success } = collection.advanced_query_validator_server.safeParse(parsed_advanced_query);
+                if(!parsed_advanced_query_success){
+                    res.status(400);
+                    res.json({ error: parsed_advanced_query_error.issues });
+                    return;
+                }
+                find = { $and: [find, advanced_query]}
+            }
+            
            
             let documents;
             try {

package/src/code_generation/templates/utils.ts.mustache

@@ -3,6 +3,7 @@
 export function encode_search_params(params: {[key: string]: string | number | boolean | string[] | Date}): {[key: string]: string | number | boolean }{
     let retval: {[key: string]: string | number | boolean } = {}
     for(let [key, value] of Object.entries(params)){
+        if(key === 'advanced_query') { retval[key] = JSON.stringify(value); continue; }
         if(Array.isArray(value)){
             retval[key] = value.join(',')
         } else if(value instanceof Date){

package/src/utils/complex_query_validator_from_zod.ts

@@ -0,0 +1,252 @@
+import { z } from "zod/v4"
+import { $ZodLooseShape } from "zod/v4/core";
+import { z_mongodb_id, z_mongodb_id_nullable, z_mongodb_id_optional } from "./mongoose_from_zod.js";
+import { find_loops, validator_group } from './zod_loop_seperator.js'
+
+type type_filters = {
+    path: string,
+    filter: z.ZodType,
+    sortable: boolean,
+}[]
+type Mode = 'client' | 'server'
+
+export function complex_query_validator_from_zod(zod_definition: z.ZodObject, mode: Mode = 'server'){
+    let loops = find_loops(zod_definition as z.ZodType);
+
+    let object_filter = {} as $ZodLooseShape;
+    let object_filters = parse_object(zod_definition._zod.def, '', loops, mode);
+    for(let filter of object_filters){
+        object_filter[filter.path.slice(1)] = filter.filter;
+    }                                
+    let compiled_object_filter = z.object(object_filter)
+
+    let and = z.object({ 
+        get $and(){ return z.array(z.union([and, or, compiled_object_filter])); },
+    });
+    let or = z.object({
+        get $or(){ return z.array(z.union([and, or, compiled_object_filter])); },
+    });
+
+    return z.union([and, or]);
+}
+
+function parse_any(zod_definition: z.ZodTypeAny, prefix: string, loop_detector: Map<any, validator_group>, 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(!zod_definition.meta()) {
+                throw new Error(`could not find custom parser in the magic value dictionary`)
+            }
+            let { framework_override_type } = zod_definition.meta();
+
+            if(framework_override_type === 'mongodb_id'){
+                return parse_mongodb_id(prefix, mode);
+            } else {
+                throw new Error(`could not find custom parser for ${framework_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: Map<any, validator_group>, 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'){
+        //@ts-ignore
+        if(!def.element.meta()) {
+            return [];
+        }
+        //@ts-ignore
+        let { framework_override_type } = def.element.meta();
+
+        if(framework_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: Map<any, validator_group>, mode: Mode): type_filters {
+    if(loop_detector.has(def)) {
+        return [];
+    }
+    
+    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));
+    if(filter_queue.length === 0){ return []; }
+    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 {
+    return [
+            {
+                path: prefix,
+                filter: z.union([
+                    z.object({
+                        $eq: z.string()
+                    }),
+                    z.object({
+                        $in: z.array(z.string())
+                    }),
+                    z.object({
+                        $nin: z.array(z.string())
+                    }),
+                ]).optional(),
+                sortable: true,
+            },
+        ];
+}
+
+function parse_enum(definition: z.core.$ZodEnumDef, prefix: string, mode: Mode): type_filters {
+    return [
+        {
+            path: prefix,
+            filter: z.union([
+                z.object({
+                    $eq: z.enum(definition.entries)
+                }),
+                z.object({
+                    $in: z.array(z.enum(definition.entries))
+                }),
+            ]).optional(),
+            sortable: true,
+        }
+    ];
+}
+
+function parse_boolean(prefix: string, mode: Mode): type_filters {
+    return [{
+        path: prefix,
+        filter: z.object({
+            $eq: z.boolean()
+        }).optional(),
+        sortable: true,
+    }];
+}
+
+function parse_number(prefix: string, mode: Mode): type_filters {
+    return [{
+        path: prefix,
+        filter: z.union([
+            z.object({  
+                $eq: z.number()
+            }),
+            z.object({
+                $gt: z.number()
+            }),
+            z.object({
+                $lt: z.number()
+            }),
+            z.object({
+                $gte: z.number()
+            }),
+            z.object({
+                $lte: z.number()
+            }),
+        ]).optional(),
+        sortable: true,
+    }];
+}
+
+function parse_date(prefix: string, mode: Mode): type_filters {
+    let date_parser = mode === 'client' ? z.date() : z.coerce.date();
+    return [{
+        path: prefix,
+        filter: z.union([
+            z.object({  
+                $eq: date_parser
+            }),
+            z.object({
+                $gt: date_parser
+            }),
+            z.object({
+                $lt: date_parser
+            }),
+            z.object({
+                $gte: date_parser
+            }),
+            z.object({
+                $lte: date_parser
+            }),
+        ]).optional(),
+        sortable: true,
+    }];
+}
+
+
+function parse_mongodb_id(prefix: string, mode: Mode): type_filters {
+    return [
+        {
+            path: prefix,
+            filter: z.union([
+                z.object({  
+                    $eq: z_mongodb_id
+                }),
+                z.object({
+                    $gt: z_mongodb_id
+                }),
+                z.object({
+                    $lt: z_mongodb_id
+                }),
+                z.object({
+                    $gte: z_mongodb_id
+                }),
+                z.object({
+                    $lte: z_mongodb_id
+                }),
+                z.object({
+                    $in: z.array(z_mongodb_id)
+                }),
+                z.object({
+                    $nin: z.array(z_mongodb_id)
+                }),
+            ]).optional(),
+            sortable: true,
+        }
+    ];
+}

package/src/utils/query_object_to_mongodb_query.ts

@@ -1,4 +1,5 @@
 import { QueryWithHelpers } from "mongoose";
+import escapeStringRegexp from 'escape-string-regexp';
 
 export let complex_query_map = {
     '_gt': '$gt',
@@ -12,7 +13,10 @@ export let complex_query_map = {
     '_ends_with': (key, value) => {
         return new RegExp(escapeRegExp(value) + '$')
     },*/
-    '_in': '$in'
+    '_in': '$in',
+    '_search': (val: string) => {
+        return { $regex: new RegExp(escapeStringRegexp(val)), $options: 'i' }
+    }
 }
 
 export let query_meta_map = {
@@ -21,6 +25,7 @@ export let query_meta_map = {
     'sort': true,
     'sort_order': true,
     //'projection': true,
+    'advanced_query': true,
 }
 
 export function convert_null(query_object: any){
@@ -32,7 +37,7 @@ export function convert_null(query_object: any){
     return query_object;
 }
 
-export function query_object_to_mongodb_query(query_object: any){
+export function query_object_to_mongodb_query(query_object: { [key: string]: string | null }){
     let retval = {} as any;
 
     for(let [key, value] of Object.entries(query_object)){
@@ -42,7 +47,10 @@ export function query_object_to_mongodb_query(query_object: any){
             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;
+            if(typeof complex_query_map[complex_suffix] ==='string') { retval[modified_key][complex_query_map[complex_suffix]] = value }
+            else {
+                retval[modified_key] = complex_query_map[complex_suffix](value)
+            }
         } else {
             retval[key] = value;
         }

package/src/utils/query_validator_from_zod.ts

@@ -2,6 +2,7 @@ import { z } from "zod/v4"
 import { $ZodLooseShape } from "zod/v4/core";
 import { z_mongodb_id, z_mongodb_id_nullable, z_mongodb_id_optional } from "./mongoose_from_zod.js";
 import { find_loops, validator_group } from './zod_loop_seperator.js'
+import { complex_query_validator_from_zod } from "./complex_query_validator_from_zod.js";
 
 type type_filters = {
     path: string,
@@ -16,7 +17,8 @@ export function query_validator_from_zod(zod_definition: z.ZodObject, mode: Mode
     let retval = {
         limit: z.coerce.number().int().optional(),
         cursor: z_mongodb_id_optional,
-        sort_order: z.enum([/*'asc', 'desc', */'ascending', 'descending']).optional()
+        sort_order: z.enum([/*'asc', 'desc', */'ascending', 'descending']).optional(),
+        advanced_query: z.string().optional(),
     } as $ZodLooseShape;
 
     let object_filters = parse_object(zod_definition._zod.def, '', loops, mode);
@@ -139,6 +141,11 @@ function parse_string(prefix: string, mode: Mode): type_filters {
                 filter: z.string().optional(),
                 sortable: false,
             },
+            {
+                path: prefix + '_search',
+                filter: z.string().optional(),
+                sortable: false,
+            },
             {
                 path: prefix + '_in',
                 filter: array_parser.optional(),

package/src/utils/zod_loop_seperator.ts

@@ -29,6 +29,11 @@ function discover_loops(
         console.error(zod_definition);
     }
 
+    if(!zod_definition._zod) {
+        console.error('ISSUE 2');
+        console.error(zod_definition);
+    }
+
     switch (zod_definition._zod.def.type) {
         case "object":
             parse_object(zod_definition as z.ZodObject,  validator_groups);

package/test/0_3_query_validator_to_mongodb_query.test.ts

@@ -174,6 +174,24 @@ describe('query validator to mongodb query', function () {
         )
     });
 
+    it('should be able to transform search', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.string(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param_search: 'den'
+            })),
+            {
+                param: {
+                    $regex: /den/,
+                    $options: 'i'
+                }
+            }
+        )
+    });
+
     it('should be able to discard controllers', async function () {
         let query_validator = query_validator_from_zod(z.object({
             param: z.number(),