@liminalfunctions/framework 1.0.0

package/test/0_2_query_validator_to_mongodb_query.test.ts

@@ -0,0 +1,365 @@
+import assert from "assert";
+import { array, boolean, z, ZodBoolean, ZodDate, ZodNumber, ZodString } from 'zod'
+
+import { z_mongodb_id } from '../dist/utils/mongoose_from_zod.js';
+import { query_validator_from_zod } from '../dist/utils/query_validator_from_zod.js';
+import { query_object_to_mongodb_query, query_object_to_mongodb_limits } from '../dist/utils/query_object_to_mongodb_query.js';
+import { Schema } from 'mongoose'
+
+import { Cache } from '../dist/utils/cache.js'
+
+describe('query validator to mongodb query', function () {
+
+    class Query_Mock {
+        filter: any
+        meta: any
+
+        constructor(){
+            this.filter = {};
+            this.meta = {};
+
+        }
+
+        sort(sort){
+            this.meta.sort = sort;
+        }
+
+        limit(limit){
+            this.meta.limit = limit;
+        }
+
+        gt(path, value){
+            this.filter[path] = {
+                $gt: value
+            }
+        }
+
+        lt(path, value){
+            this.filter[path] = {
+                $lt: value
+            }
+        }
+    }
+
+
+    it('should be able to transform basic parameters into a mongodb query', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            enum: z.enum(['one', 'two']),
+            string: z.string(),
+            number: z.number(),
+            int: z.int(),
+            nest: z.object({
+                nested: z.string()
+            }),
+            boolean: z.boolean(),
+            date: z.date(),
+            object_id: z_mongodb_id,
+            array: z.array(z.string())
+        }))
+
+        let date = new Date();
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                enum: 'one',
+                string: 'string',
+                number: '54',
+                int: '43',
+                'nest.nested': 'panko',
+                boolean: 'true',
+                date: date.toISOString(),
+                object_id: '6894cba684185cb03275d511',
+                array: 'chupacabra'
+            })),
+            {
+                enum: 'one',
+                string: 'string',
+                number: 54,
+                int: 43,
+                'nest.nested': 'panko',
+                boolean: true,
+                date: date,
+                object_id: '6894cba684185cb03275d511',
+                array: 'chupacabra'
+            }
+        )
+    });
+
+    it('should be able to transform gt', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param_gt: '5'
+            })),
+            {
+                param: {
+                    $gt: 5
+                }
+            }
+        )
+    });
+
+    it('should be able to transform gte', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param_gte: '5'
+            })),
+            {
+                param: {
+                    $gte: 5
+                }
+            }
+        )
+    });
+
+    it('should be able to transform lt', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param_lt: '5'
+            })),
+            {
+                param: {
+                    $lt: 5
+                }
+            }
+        )
+    });
+
+    it('should be able to transform lte', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param_lte: '5'
+            })),
+            {
+                param: {
+                    $lte: 5
+                }
+            }
+        )
+    });
+
+    it('should be able to transform in', 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_in: 'test1,test2,test3'
+            })),
+            {
+                param: {
+                    $in: ['test1', 'test2', 'test3']
+                }
+            }
+        )
+    });
+
+    it('should be able to discard controllers', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        assert.deepEqual(
+            query_object_to_mongodb_query(query_validator.parse({
+                param: '5',
+                limit: 6,
+                cursor: '6894cba684185cb03275d511',
+                sort: 'param',
+                sort_order: 'descending'
+            })),
+            {
+                param: 5
+            }
+        )
+    });
+    
+    it('should be able to extract sort metadata', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            sort: 'param',
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {}
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 100,
+                sort: {
+                    param: 'ascending'
+                }
+            }
+        )
+    });
+
+    it('should be able to extract sort metadata with a sort order', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            sort: 'param',
+            sort_order: 'descending'
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {}
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 100,
+                sort: {
+                    param: 'descending'
+                }
+            }
+        )
+    });
+
+    
+    it('should sort by ID if given a sort order without a sort field', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            sort_order: 'descending'
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {}
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 100,
+                sort: {
+                    _id: 'descending'
+                }
+            }
+        )
+    });
+
+    it('should be able to extract limit metadata', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            limit: '5',
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {}
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 5
+            }
+        )
+    });
+
+    it('should default to sane limits', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            limit: '5000',
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {}
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 100
+            }
+        )
+    });
+
+    it('should filter by ID when using a cursor', async function () {
+        let query_validator = query_validator_from_zod(z.object({
+            param: z.number(),
+        }))
+
+        let query = new Query_Mock();
+
+        //@ts-expect-error
+        query_object_to_mongodb_limits(query, query_validator.parse({
+            param: '5',
+            cursor: '6894cba684185cb03275d511',
+        }));
+
+        assert.deepEqual(
+            query.filter,
+            {
+                _id: {
+                    $gt: '6894cba684185cb03275d511'
+                }
+            }
+        )
+
+        assert.deepEqual(
+            query.meta,
+            {
+                limit: 100,
+                sort: {
+                    _id: 'ascending'
+                }
+            }
+        )
+    });
+});

package/test/0_3_cache.test.ts

@@ -0,0 +1,204 @@
+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 { Cache } from '../dist/utils/cache.js'
+
+describe('Cache', function () {
+
+    function sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+
+    it('should be able to set and regurgitate elements at a key', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        cache.set(key, value);
+        assert.deepEqual(cache.get(key), value);
+    });
+
+    it('should be able to set and regurgitate elements at a key using the first_get_then_fetch method', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        assert.deepEqual(await cache.first_get_then_fetch(key, async () => value), value);
+    });
+
+    it('should set values in the cache for later retrieval when using the first_get_then_fetch method', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+
+        await cache.first_get_then_fetch(key, async () => value)
+        
+        assert.deepEqual(cache.get(key), value);
+    });
+
+    it('cache values set through the standard set method should expire', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        cache.set(key, value);
+
+        await sleep(20);
+
+        assert.deepEqual(cache.get(key), undefined);
+    });
+
+    it('cache values set through the first_get_then_fetch method should expire', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        await cache.first_get_then_fetch(key, async () => value)
+
+        await sleep(20);
+
+        assert.deepEqual(cache.get(key), undefined);
+    });
+
+    it('if should delay throwing away the cached value every time the key is set', async function () {
+        let cache = new Cache(5);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        cache.set(key, value);
+        await sleep(2);
+        cache.set(key, value);
+        await sleep(2);
+        cache.set(key, value);
+        await sleep(2);
+        cache.set(key, value);
+        await sleep(2);
+        cache.set(key, value);
+        await sleep(2);
+        cache.set(key, value);
+        await sleep(2);
+
+        assert.deepEqual(cache.get(key), value);
+    });
+
+    it('if should delay throwing away the cached value every time the key is fetched', async function () {
+        let cache = new Cache(5);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        cache.set(key, value);
+        await sleep(2);
+        cache.get(key);
+        await sleep(2);
+        cache.get(key);
+        await sleep(2);
+        cache.get(key);
+        await sleep(2);
+        cache.get(key);
+        await sleep(2);
+        cache.get(key);
+        await sleep(2);
+
+        assert.deepEqual(cache.get(key), value);
+    });
+
+    it('if the first_get_then_fetch method throws an error, it should be passed upstream to be caught.', async function () {
+        let cache = new Cache(10);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        assert.rejects(async() => {
+            await cache.first_get_then_fetch(key, async () => { throw new Error('bad data here bro') })
+        }, {message: 'bad data here bro'})
+    });
+
+    it('if the first_get_then_fetch method is called multiple times, the fetch method should run only once.', async function () {
+        let cache = new Cache(30);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        let run_counter = 0;
+
+        cache.first_get_then_fetch(key, async () => { run_counter++; await sleep(5); return value; })
+        cache.first_get_then_fetch(key, async () => { run_counter++; await sleep(5); return value; })
+        cache.first_get_then_fetch(key, async () => { run_counter++; await sleep(5); return value; })
+        await cache.first_get_then_fetch(key, async () => { run_counter++; await sleep(5); return value; })
+        await sleep(5);
+
+        assert.deepEqual(cache.get(key), value);
+        assert.deepEqual(run_counter, 1);
+    });
+
+    it('if the first_fetch_then_refresh method is called and the key is not in the cache, it should be fetched', async function () {
+        let cache = new Cache(30);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        let fetch_method = async () => { return value; };
+
+        await cache.first_fetch_then_refresh(key, fetch_method)
+
+        assert.deepEqual(cache.get(key), value);
+    });
+
+    it('if the first_fetch_then_refresh method is called multiple times, the fetch method should run only once.', async function () {
+        let cache = new Cache(30);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        let fetch_method = async () => { run_counter++; await sleep(5); return value; };
+        let run_counter = 0;
+
+        cache.first_fetch_then_refresh(key, fetch_method)
+        cache.first_fetch_then_refresh(key, fetch_method)
+        cache.first_fetch_then_refresh(key, fetch_method)
+        await cache.first_fetch_then_refresh(key, fetch_method)
+        await sleep(5);
+
+        assert.deepEqual(cache.get(key), value);
+        assert.deepEqual(run_counter, 1);
+    });
+
+    
+    it('if the first_fetch_then_refresh method is called when the cache already has the key, it should still refetch after the value is returned.', async function () {
+        let cache = new Cache(30);
+
+        const key = 'best_animal'
+        const value = { 'test': 'flamingo' }
+        
+        let fetch_method = async () => { await sleep(5); run_counter++; return value; };
+        let run_counter = 0;
+
+        cache.set(key, value);
+
+        assert.deepEqual(cache.get(key), value);
+        assert.deepEqual(run_counter, 0);
+
+        let fetch_promise = cache.first_fetch_then_refresh(key, fetch_method)
+
+        assert.deepEqual(run_counter, 0);
+
+        await fetch_promise;
+        await sleep(7);
+
+        assert.deepEqual(cache.get(key), value);
+        assert.deepEqual(run_counter, 1);
+    });
+
+});