@liminalfunctions/framework 1.0.68 → 1.0.71

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')){
@@ -247,7 +252,7 @@ export class F_Collection<Collection_ID extends string, ZodSchema extends z.ZodO
         let deleted_document_data;
 
         // if we have any update hooks, run the update operation in a transaction
-        if(this.update_hooks.length > 0){
+        if(this.delete_hooks.length > 0){
             await mongoose.connection.transaction(async (session) => {
                 // update the document
                 let deleted_document = await this.mongoose_model.findOneAndDelete(find, {returnDocument: 'after', session: session, lean: true})

package/src/F_Compile.ts

@@ -151,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,259 @@
+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 escapeStringRegexp from "escape-string-regexp";
+
+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())
+                    }),
+                    z.object({
+                        $regex: z.transform((val) => {
+                            if(typeof val !== 'string'){ return false; }
+                            return escapeStringRegexp(val);
+                        })
+                    }),
+                ]).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

@@ -25,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){

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);

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);