@liminalfunctions/framework 1.0.51 → 1.0.53

package/src/code_generation/generate_client_library.ts

@@ -26,9 +26,18 @@ function build_path(...args: string[]){
 export async function generate_client_library<Collections>(output_path: string, collection_registry: F_Collection_Registry<Collections>, service_name = 'default-service') {
     let api_builder: api_builder = {
         mustache_context: {},
-        children: {}
+        children: {},
     };
 
+    if(!existsSync(build_path(output_path, 'src'))){ await mkdir(build_path(output_path, 'src')); }
+    if(!existsSync(build_path(output_path, 'dist'))){ await mkdir(build_path(output_path, 'dist')); }
+    if(!existsSync(build_path(output_path, 'src', 'types'))){ await mkdir(build_path(output_path, 'src', 'types')); }
+    if(!existsSync(build_path(output_path, 'src', 'utils'))){ await mkdir(build_path(output_path, 'src', 'utils')); }
+    await writeFile(build_path(output_path, 'src', 'utils', 'utils.ts'), await readFile(fileURLToPath(import.meta.resolve('./templates/utils.ts.mustache')), { encoding: 'utf-8' }));
+    await writeFile(build_path(output_path, 'tsconfig.json'), await readFile(fileURLToPath(import.meta.resolve('./templates/tsconfig.json.mustache')), { encoding: 'utf-8' }));
+    await writeFile(build_path(output_path, '.gitignore'), await readFile(fileURLToPath(import.meta.resolve('./templates/.gitignore.mustache')), { encoding: 'utf-8' }));
+        
+
     // build the typescript types
     for(let col of Object.values(collection_registry.collections)){
         let collection = col as F_Collection<string, any>;
@@ -48,6 +57,27 @@ export async function generate_client_library<Collections>(output_path: string,
 
             type_post: `${get_type_name(collection.collection_id)}_post`,
             path_type_post: `types/${get_type_name(collection.collection_id)}_post`,
+
+            array_children: [] as any[],
+            has_array_children: false,
+        }
+
+        for(let [array_child_key, array_child_validator] of collection.array_children_map.entries()){
+            let array_child_put_type = type_from_zod(array_child_validator);
+            let array_child_post_type = type_from_zod(collection.array_children_post_map.get(array_child_key));
+            let type_name = get_array_child_type_name(mustache_context.type_return, array_child_key);
+            let type_put_name = `${type_name}_put`
+            let type_post_name = `${type_name}_post`
+
+            let array_child_mustache_context = {
+                array_name: array_child_key,
+                type_array_child_put: type_put_name,
+                array_type_put_definition: `export type ${type_put_name} = ${array_child_put_type[0]}\n${array_child_put_type.slice(1)}`,
+                type_array_child_post: type_post_name,
+                array_type_post_definition: `export type ${type_post_name} = ${array_child_post_type[0]}\n${array_child_post_type.slice(1)}`,
+            };
+            mustache_context.array_children.push(array_child_mustache_context);
+            mustache_context.has_array_children = true;
         }
 
         let collection_type_definition_builder = [] as string[];
@@ -66,13 +96,6 @@ export async function generate_client_library<Collections>(output_path: string,
         let collection_type_post = type_from_zod(collection.post_validator);
         collection_post_type_definition_builder.push(`export type ${mustache_context.type_post} = ${collection_type_post[0]}`, ...collection_type_post.slice(1));
 
-        if(!existsSync(build_path(output_path, 'src'))){ await mkdir(build_path(output_path, 'src')); }
-        if(!existsSync(build_path(output_path, 'dist'))){ await mkdir(build_path(output_path, 'dist')); }
-        if(!existsSync(build_path(output_path, 'src', 'types'))){ await mkdir(build_path(output_path, 'src', 'types')); }
-        if(!existsSync(build_path(output_path, 'src', 'utils'))){ await mkdir(build_path(output_path, 'src', 'utils')); }
-        await writeFile(build_path(output_path, 'src', 'utils', 'utils.ts'), await readFile(fileURLToPath(import.meta.resolve('./templates/utils.ts.mustache')), { encoding: 'utf-8' }));
-        await writeFile(build_path(output_path, 'tsconfig.json'), await readFile(fileURLToPath(import.meta.resolve('./templates/tsconfig.json.mustache')), { encoding: 'utf-8' }));
-        await writeFile(build_path(output_path, '.gitignore'), await readFile(fileURLToPath(import.meta.resolve('./templates/.gitignore.mustache')), { encoding: 'utf-8' }));
         await writeFile(build_path(output_path, 'src', mustache_context.path_type_return + '.ts'), collection_type_definition_builder.join('\n'));
         await writeFile(build_path(output_path, 'src', mustache_context.path_type_query + '.ts'), collection_query_type_definition_builder.join('\n'));
         await writeFile(build_path(output_path, 'src', mustache_context.path_type_put + '.ts'), collection_put_type_definition_builder.join('\n'));
@@ -155,6 +178,10 @@ export function get_type_name(collection_id: string, suffix?: string): string {
     return suffix ? `${collection_id}_${suffix}`.replace(/[^(a-zA-Z0-9\_)]/g, '_') : collection_id.replace(/[^(a-zA-Z0-9\_)]/g, '_');
 }
 
+export function get_array_child_type_name(collection_id: string, array_key: string): string {
+    return collection_id + '_' + array_key.replace(/[^(a-zA-Z0-9\_)]/g, '_');
+}
+
 export function uppercase(str: string): string {
     let upper_on = true;
     let joinable = [];

package/src/code_generation/templates/collection.mustache

@@ -130,4 +130,82 @@ class Document {
         }
     }
     {{/has_subcollections}}
-}
+
+    {{#has_array_children}}
+    {{#array_children}}
+    array(key: "{{array_name}}"): Collection_{{my_built_collection}}_Array_{{array_name}};
+    {{/array_children}}
+    array(key: string) {
+        switch(key) {
+            {{#array_children}}
+            case "{{array_name}}":
+                return new Collection_{{my_built_collection}}_Array_{{array_name}}([...this.path, this.document_id, "{{array_name}}"], this.get_auth);
+            {{/array_children}}
+            default:
+                throw new Error(`Collection ${this.collection_id} does not have an array at the key ${key}`)
+        }
+    }
+    {{/has_array_children}}
+}
+
+{{#array_children}}
+{{array_type_put_definition}}
+{{array_type_post_definition}}
+
+export class Collection_{{my_built_collection}}_Array_{{array_name}} {
+    path: string[]
+    get_auth: () => Promise<any>
+    collection_id: string
+    collection_name_plural: string
+    array_key: string
+
+    constructor(path: string[], get_auth: () => Promise<any>) {
+        this.path = path;
+        this.get_auth = get_auth;
+        this.collection_id = "{{collection_id}}";
+        this.collection_name_plural = "{{collection_name_plural}}"
+        this.array_key = "{{array_name}}"
+    }
+
+    async push(document: {{type_array_child_post}}): Promise<{{type_return}}>{
+        try {
+            let result = await ky.post(this.path.join('/'), {
+                headers: {
+                    authorization: await this.get_auth()
+                },
+                json: document
+            }).json() as Response<{{type_return}}>;
+            return result.data;
+        } catch(err){
+            return Promise.reject(err)
+        }
+    }
+
+    async replace(document: {{type_array_child_put}}): Promise<{{type_return}}>{
+        try {
+            let result = await ky.put([...this.path, document._id].join('/'), {
+                headers: {
+                    authorization: await this.get_auth()
+                },
+                json: document
+            }).json() as Response<{{type_return}}>;
+            return result.data;
+        } catch(err){
+            return Promise.reject(err)
+        }
+    }
+
+    async delete(document_id: string): Promise<{{type_return}}>{
+        try {
+            let result = await ky.delete([...this.path, document_id].join('/'), {
+                headers: {
+                    authorization: await this.get_auth()
+                }
+            }).json() as Response<{{type_return}}>;
+            return result.data;
+        } catch(err){
+            return Promise.reject(err)
+        }
+    }
+}
+{{/array_children}}

package/src/utils/array_children_from_zod.ts

@@ -0,0 +1,44 @@
+import z from "zod/v4";
+import { find_loops, validator_group } from './zod_loop_seperator.js'
+
+export function array_children_from_zod(zod_definition: z.ZodObject, loop_detector?: Map<any, validator_group>, built_map?: Map<string, z.ZodObject>, prefix: string = ''): Map<string, z.ZodObject> {
+    let loops = loop_detector ?? find_loops(zod_definition as z.ZodType);
+    let results = built_map ?? new Map<string, z.ZodObject>();
+
+    for(let [key, value] of Object.entries(zod_definition.shape)){
+        if(loops.has(value._zod.def)){ continue; }
+        let real_value = distill_zod(value);
+        switch (real_value._zod.def.type) {
+            case "object":
+                array_children_from_zod(real_value as z.ZodObject, loop_detector, results, prefix.length > 0 ? `${prefix}.${key}` : key)
+                break;
+            case "array":
+                //@ts-ignore
+                let element = distill_zod((real_value as z.ZodArray).element);
+                if(element._zod.def.type === 'object') {
+                    let objdef = element._zod.def as z.core.$ZodObjectDef;
+                    if(objdef.shape._id){
+                        results.set(prefix.length > 0 ? `${prefix}.${key}` : key,  element as z.ZodObject);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+
+    }
+    return results;
+}
+
+function distill_zod(zod_definition: z.ZodType): z.ZodType {
+    switch (zod_definition._zod.def.type) {
+        case "nullable":
+            //@ts-ignore
+            return zod_definition._zod.def.innerType;
+        case "optional":
+            //@ts-ignore
+            return zod_definition._zod.def.innerType;
+        default:
+            return zod_definition;
+    }
+}

package/src/utils/mongoose_from_zod.ts

@@ -100,10 +100,10 @@ export function schema_entry_from_zod(zod_definition: z.ZodType, loop_detector:
             result.required = !zod_definition.safeParse(undefined).success
             return result;
         case "nullable":
-            // stuff is nullable in mongodb by default, so just return the ordinary results of the parse
-            //@ts-expect-error
-            return schema_entry_from_zod((zod_definition as z.core.$ZodNullable)._zod.def.innerType, loop_detector)
         case "optional":
+            // stuff is nullable in mongodb by default, so just return the ordinary results of the parse
+            ////@ts-expect-error
+            //return schema_entry_from_zod((zod_definition as z.core.$ZodNullable)._zod.def.innerType, loop_detector)
             return parse_optional(zod_definition._zod.def as z.core.$ZodOptionalDef, loop_detector);
         case "record":
             result = parse_record(zod_definition._zod.def as z.core.$ZodRecordDef, loop_detector);
@@ -171,6 +171,10 @@ function parse_object(def: z.core.$ZodObjectDef, loop_detector: Map<any, validat
         //@ts-ignore
         retval[key] = schema_entry_from_zod(value, loop_detector);
     }
+
+    // handle the edge cases arouund mongoose's auto-IDs
+    if(!retval._id){ retval._id = false; }
+    else { delete retval._id; }
     return {mongoose_type: retval, required: true};
 }
 

package/test/0_1_mongoose_from_zod.test.ts

@@ -69,7 +69,7 @@ describe('Mongoose from Zod', function () {
         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: { mongoose_type: basic_type.mongoose_type, required: true } }, mongooseSchema)
+            assert.deepEqual({ test_value: { mongoose_type: basic_type.mongoose_type, required: false } }, mongooseSchema)
         });
 
         it(`should convert ${basic_type.label} to mongoose type with optional AND default values`, function () {
@@ -87,20 +87,26 @@ describe('Mongoose from Zod', function () {
         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: { mongoose_type: {test_value: { mongoose_type: basic_type.mongoose_type, required: true }}, required: true} }, mongooseSchema)
+            assert.deepEqual({ test_value: { mongoose_type: { _id: false, test_value: { mongoose_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: { mongoose_type: {test_value: { mongoose_type: basic_type.mongoose_type, required: false }}, required: true } }, mongooseSchema)
+            assert.deepEqual({ test_value: { mongoose_type: {_id: false, test_value: { mongoose_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: { mongoose_type: {test_value: {  mongoose_type: basic_type.mongoose_type, required: true, default: basic_type.default_val }}, required: true } }, mongooseSchema)
+            assert.deepEqual({ test_value: { mongoose_type: {_id: false, test_value: { mongoose_type: basic_type.mongoose_type, required: true, default: basic_type.default_val }}, required: true } }, mongooseSchema)
+        });
+
+        it(`should convert a nested object containing a ${basic_type.label} property to mongoose type while allowing for auto-ID`, function () {
+            let zodSchema = z.object({ test_value: z.object({_id: z_mongodb_id_optional, test_value: basic_type.zod_function() }) })
+            let mongooseSchema = schema_from_zod(zodSchema)
+            assert.deepEqual({ test_value: { mongoose_type: {test_value: { mongoose_type: basic_type.mongoose_type, required: true }}, required: true} }, mongooseSchema)
         });
     }
 
@@ -268,14 +274,14 @@ describe('Mongoose from Zod', function () {
             c: z.object({
                 name: z.string()
             }),
-        })
-        let mongooseSchema = schema_from_zod(zodSchema)
+        });
+        let mongooseSchema = schema_from_zod(zodSchema);
 
         assert.deepEqual({ 
-            a: { mongoose_type: { name: { mongoose_type: String, required: true } }, required: true },
-            b: { mongoose_type: { name: { mongoose_type: String, required: true } }, required: true },
-            c: { mongoose_type: { name: { mongoose_type: String, required: true } }, required: true },
-        }, mongooseSchema)
+            a: { mongoose_type: { _id: false, name: { mongoose_type: String, required: true } }, required: true },
+            b: { mongoose_type: { _id: false, name: { mongoose_type: String, required: true } }, required: true },
+            c: { mongoose_type: { _id: false, name: { mongoose_type: String, required: true } }, required: true },
+        }, mongooseSchema);
     })
 
     /*

package/test/0_6_array_children.test.ts

@@ -0,0 +1,127 @@
+import assert from "assert";
+import { z, ZodBoolean, ZodDate, ZodNumber, ZodString } from 'zod'
+
+import { array_children_from_zod } from '../dist/utils/array_children_from_zod.js';
+import mongoose, { Schema } from 'mongoose'
+import { required } from "zod/mini";
+import { z_mongodb_id } from "../dist/utils/mongoose_from_zod.js";
+
+process.env.DEBUG = 'express:*'
+
+describe('Mongoose from Zod', function () {
+    it('should detect no loops in an empty object', function () {
+        let zodSchema = z.object({ })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 0)
+    });
+
+    it('should detect an array child if one exists', function () {
+        let zodSchema = z.object({ 
+            val: z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            }))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 1)
+    });
+
+    it('should detect multiple array children if they exist', function () {
+
+        let zodSchema = z.object({ 
+            val: z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            })),
+            other_val: z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            }))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 2)
+    });
+
+    it('should detect array children within nullable', function () {
+        let zodSchema = z.object({ 
+            val: z.nullable(z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            })))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 1)
+    });
+
+    it('should detect array children within optional', function () {
+        let zodSchema = z.object({ 
+            val: z.optional(z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            })))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 1)
+    });
+
+    it('should detect array children nested within an object', function () {
+        let zodSchema = z.object({ 
+            alpha: z.object({
+                val: z.array(z.object({
+                    _id: z_mongodb_id,
+                    test: z.string()
+                }))
+            })
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(array_children.size, 1)
+    });
+
+    it('should have correct array children and nested array children names', function () {
+        let zodSchema = z.object({ 
+            alpha: z.object({
+                val: z.array(z.object({
+                    _id: z_mongodb_id,
+                    test: z.string()
+                }))
+            }),
+            latex: z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            }))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(Array.from(array_children.keys()).includes('alpha.val'), true);
+        assert.equal(Array.from(array_children.keys()).includes('latex'), true);
+    });
+
+    it('should return the validator for a child', function () {
+        let zodSchema = z.object({ 
+            val: z.array(z.object({
+                _id: z_mongodb_id,
+                test: z.string()
+            }))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        let objectid = new mongoose.Types.ObjectId()
+        assert.deepEqual(array_children.get('val')?.parse({_id: '' + objectid, test: 'testval'}), {_id: '' + objectid, test: 'testval'})
+    });
+
+    
+    it('should only detect array children that have an _id field', function () {
+        let zodSchema = z.object({ 
+            alpha: z.object({
+                val: z.array(z.object({
+                    _id: z_mongodb_id,
+                    test: z.string()
+                }))
+            }),
+            latex: z.array(z.object({
+                test: z.string()
+            }))
+        })
+        let array_children = array_children_from_zod(zodSchema);
+        assert.equal(Array.from(array_children.keys()).includes('alpha.val'), true);
+        assert.equal(Array.from(array_children.keys()).includes('latex'), false);
+    });
+});

package/test/1_0_basic_server.test.ts

@@ -1,7 +1,7 @@
 
 import assert from "assert";
 
-import { z_mongodb_id } from '../dist/utils/mongoose_from_zod.js';
+import { z_mongodb_id, z_mongodb_id_optional } from '../dist/utils/mongoose_from_zod.js';
 import { F_Collection } from '../dist/f_collection.js';
 import { F_Collection_Registry } from '../dist/F_Collection_Registry.js'
 import { F_SM_Open_Access } from '../dist/F_Security_Models/F_SM_Open_Access.js'
@@ -41,10 +41,20 @@ describe('Basic Server', function () {
         client_id: z_mongodb_id,
         name: z.string(),
     });
+    const validate_list_container = z.object({
+        _id: z_mongodb_id,
+        container: z.object({
+            list: z.array(z.object({
+                _id: z_mongodb_id_optional,
+                value: z.string()
+            }))
+        })
+    });
 
     let institution: F_Collection<'institution', typeof validate_institution>;
     let client: F_Collection<'client', typeof validate_client>;
     let project: F_Collection<'project', typeof validate_project>;
+    let list_container: F_Collection<'list_container', typeof validate_list_container>;
 
     let registry: F_Collection_Registry;
     
@@ -67,9 +77,12 @@ describe('Basic Server', function () {
         project = new F_Collection('project', 'projects', validate_project);
         project.add_layers([institution.collection_id, client.collection_id], [new F_SM_Open_Access(project)]);
 
+        list_container = new F_Collection('list_container', 'list_containers', validate_list_container);
+        list_container.add_layers([], [new F_SM_Open_Access(list_container)]);
+
         // build registry
         let proto_registry = new F_Collection_Registry();
-        registry = proto_registry.register(institution).register(client).register(project);
+        registry = proto_registry.register(institution).register(client).register(project).register(list_container);
         registry.compile(express_app, '/api');
 
         server = express_app.listen(port);
@@ -563,6 +576,40 @@ describe('Basic Server', function () {
         });
     });
 
+    it(`should reject a PUT operation that changes the document id`, async function () {
+        let test_institution = await institution.mongoose_model.create({
+            name: 'Spandex Co'
+        });
+
+        let test_client = await client.mongoose_model.create({
+            institution_id: test_institution._id,
+            name: `Bob's spandex house`
+        })
+
+        let test_project = await project.mongoose_model.create({
+            institution_id: test_institution._id,
+            client_id: test_client._id,
+            name: `Spandex Reincarnation`
+        })
+
+        let test_project_2 = await project.mongoose_model.create({
+            institution_id: test_institution._id,
+            client_id: test_client._id,
+            name: `Olfactory Hurricane`
+        })
+
+        await assert.rejects(async () => {
+            let results = await got.put(`http://localhost:${port}/api/institution/${test_institution._id}/client/${test_client._id}/project/${test_project._id}`, {
+                json: {
+                    _id: test_project_2._id,
+                    name: `Leather Pants Transubstantiation`,
+                },
+            }).json();
+        }, {
+            message: 'Response code 400 (Bad Request)'
+        });
+    });
+
     it(`should reject a PUT operation with a malicious key in the body`, async function () {
         let test_institution = await institution.mongoose_model.create({
             name: 'Spandex Co'
@@ -769,4 +816,62 @@ describe('Basic Server', function () {
         assert.deepEqual(null, results.data);
         assert.deepEqual(JSON.parse(JSON.stringify(await project.mongoose_model.findById(test_project._id))), JSON.parse(JSON.stringify(test_project)));
     });
+
+    it(`should allow entries to be added to object arrays`, async function () {
+        let test_list_container = await list_container.mongoose_model.create({
+            container: {
+                list: []
+            }
+        });
+
+        let results = await got.post(`http://localhost:${port}/api/list_container/${test_list_container._id}/container.list`, {
+            json: {
+                value: 'test value'
+            }
+        }).json();
+        
+        //@ts-ignore
+        assert.deepEqual('test value', results.data.container.list[0].value);
+        //@ts-ignore
+        assert.deepEqual(JSON.parse(JSON.stringify(await list_container.mongoose_model.findById(test_list_container._id))), JSON.parse(JSON.stringify(results.data)));
+    });
+
+    it(`should allow object array entries to be updated`, async function () {
+        let test_list_container = await list_container.mongoose_model.create({
+            container: {
+                list: [{
+                    value: 'original value'
+                }]
+            }
+        });
+
+        let results = await got.put(`http://localhost:${port}/api/list_container/${test_list_container._id}/container.list/${test_list_container.container.list[0]._id}`, {
+            json: {
+                value: 'updated value'
+            }
+        }).json();
+        
+        //@ts-ignore
+        assert.deepEqual('updated value', results.data.container.list[0].value);
+        //@ts-ignore
+        assert.deepEqual(JSON.parse(JSON.stringify(await list_container.mongoose_model.findById(test_list_container._id))), JSON.parse(JSON.stringify(results.data)));
+    });
+
+    it(`should allow object array entries to be deleted`, async function () {
+        let test_list_container = await list_container.mongoose_model.create({
+            container: {
+                list: [{
+                    value: 'original value'
+                }]
+            }
+        });
+
+        let results = await got.delete(`http://localhost:${port}/api/list_container/${test_list_container._id}/container.list/${test_list_container.container.list[0]._id}`).json();
+        
+        //@ts-ignore
+        assert.deepEqual(0, results.data.container.list.length);
+        //@ts-ignore
+        assert.deepEqual(JSON.parse(JSON.stringify(await list_container.mongoose_model.findById(test_list_container._id))), JSON.parse(JSON.stringify(results.data)));
+    });
+    
 });