springnext 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,2 +1,511 @@
-const squared = (n)=>n * n;
-export { squared };
+import zod from "zod";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var store_namespaceObject = {};
+__webpack_require__.r(store_namespaceObject);
+__webpack_require__.d(store_namespaceObject, {
+    InRAM: ()=>InRAM,
+    methods: ()=>store_zod_utils_methods,
+    toModuleMetadata: ()=>toModuleMetadata
+});
+var value_objects_namespaceObject = {};
+__webpack_require__.r(value_objects_namespaceObject);
+__webpack_require__.d(value_objects_namespaceObject, {
+    Pagination: ()=>Pagination
+});
+var zod_controller_utils_namespaceObject = {};
+__webpack_require__.r(zod_controller_utils_namespaceObject);
+__webpack_require__.d(zod_controller_utils_namespaceObject, {
+    DefaultErrorCodes: ()=>zod_controller_utils_DefaultErrorCodes,
+    endpoints: ()=>endpoints
+});
+var zod_module_utils_namespaceObject = {};
+__webpack_require__.r(zod_module_utils_namespaceObject);
+__webpack_require__.d(zod_module_utils_namespaceObject, {
+    methods: ()=>methods
+});
+const isControllerError = (error)=>{
+    if (!error || 'object' != typeof error) return false;
+    const argKeys = Object.keys(error);
+    const requiredKeys = [
+        'name',
+        'message',
+        'code',
+        'module',
+        'method',
+        'timestamp',
+        'statusCode'
+    ];
+    return requiredKeys.every((x)=>argKeys.includes(x));
+};
+const isModuleError = (arg)=>{
+    if ('object' != typeof arg || !arg) return false;
+    const argKeys = Object.keys(arg);
+    const requiredKeys = [
+        'name',
+        'message',
+        'code',
+        'module',
+        'method',
+        'timestamp'
+    ];
+    if (!requiredKeys.every((x)=>argKeys.includes(x))) return false;
+    return !argKeys.includes('statusCode');
+};
+const spawnBaseError = ({ error, code, details })=>{
+    let err = error instanceof Error ? error : new Error('unknown error');
+    if ('string' == typeof error || 'number' == typeof error) err = new Error(error?.toString());
+    if ('object' == typeof error && null !== error) if (error instanceof Error) err = error;
+    else {
+        const jsonRepresentation = JSON.stringify(error);
+        err = new Error(jsonRepresentation);
+    }
+    return {
+        message: err.message,
+        name: err.name,
+        timestamp: Date.now(),
+        code: code || err.name,
+        details: details || null
+    };
+};
+const spawnFromUnknownError = (error)=>{
+    const isErrorBase = (arg)=>{
+        if ('object' != typeof arg || !arg) return false;
+        const argKeys = Object.keys(arg);
+        const requiredKeys = [
+            'name',
+            'message',
+            'code',
+            'timestamp'
+        ];
+        return requiredKeys.every((x)=>argKeys.includes(x));
+    };
+    if (isModuleError(error)) return error;
+    if (isErrorBase(error)) return error;
+    return spawnBaseError({
+        error
+    });
+};
+const spawnModuleError = (moduleName)=>({
+        inMethod: (methodName)=>({
+                newError: (payload, cause)=>{
+                    const errorBase = spawnBaseError(payload);
+                    return {
+                        ...errorBase,
+                        cause: cause ? spawnFromUnknownError(cause) : null,
+                        module: moduleName,
+                        method: methodName
+                    };
+                }
+            })
+    });
+const spawnControllerError = (controllerName)=>({
+        inMethod: (methodName)=>({
+                newError: (payload, cause)=>{
+                    const errorBase = spawnBaseError(payload);
+                    const formattedCause = cause ? spawnFromUnknownError(cause) : null;
+                    if (!payload.code && formattedCause?.code) errorBase.code = formattedCause.code;
+                    return {
+                        ...errorBase,
+                        cause: formattedCause,
+                        module: controllerName,
+                        method: methodName,
+                        statusCode: payload.statusCode
+                    };
+                }
+            })
+    });
+const methods = (metadata, sharedConfig = {})=>(methodName, handler, config = {})=>{
+        const { name, schemas } = metadata;
+        return async (payload)=>{
+            try {
+                const parsedPayload = schemas[methodName].payload.parse(payload);
+                const response = await handler(parsedPayload, {
+                    methodError: (payload, cause)=>spawnModuleError(name).inMethod(methodName).newError('string' == typeof payload ? {
+                            error: payload,
+                            code: payload,
+                            details: parsedPayload
+                        } : payload, cause)
+                });
+                const parsedResponse = schemas[methodName].response.parse(response);
+                return parsedResponse;
+            } catch (error) {
+                if (isModuleError(error)) {
+                    if (sharedConfig.onError) await sharedConfig.onError(error);
+                    if (config.onError) await config.onError(error);
+                    throw error;
+                }
+                const serviceErrorGenerator = spawnModuleError(name).inMethod(methodName);
+                const serviceError = serviceErrorGenerator.newError({
+                    error
+                });
+                if (config.onError) await config.onError(serviceError);
+                throw serviceError;
+            }
+        };
+    };
+function jsonResponse(data, init) {
+    return new Response(JSON.stringify(data), {
+        ...init,
+        headers: {
+            'Content-Type': 'application/json',
+            ...init?.headers || {}
+        }
+    });
+}
+var zod_controller_utils_DefaultErrorCodes = /*#__PURE__*/ function(DefaultErrorCodes) {
+    DefaultErrorCodes["REQUEST_PARSING"] = "NZMT-CONTROLLER___REQUEST-PARSING";
+    DefaultErrorCodes["RESPONSE_PARSING"] = "NZMT-CONTROLLER___RESPONSE-PARSING";
+    return DefaultErrorCodes;
+}({});
+const endpoints = (metadata, sharedConfig = {})=>{
+    const endpointLogic = (method, handler, configuration = {})=>async (request)=>{
+            let requestPayload = {};
+            const errorFactory = spawnControllerError(metadata.name).inMethod(method);
+            try {
+                const endpointError = (payload, errorStatus, cause)=>{
+                    if ('string' == typeof payload) return errorFactory.newError({
+                        statusCode: errorStatus ?? 500,
+                        code: payload,
+                        error: payload,
+                        details: requestPayload
+                    }, cause);
+                    return errorFactory.newError({
+                        ...payload,
+                        statusCode: errorStatus ?? 500
+                    }, cause);
+                };
+                if (sharedConfig.guards) for (const sharedGuard of sharedConfig.guards){
+                    const error = await sharedGuard({
+                        request,
+                        endpointError
+                    });
+                    if (error) throw error;
+                }
+                if (configuration.guards) for (const endpointGuard of configuration.guards){
+                    const error = await endpointGuard({
+                        request,
+                        endpointError
+                    });
+                    if (error) throw error;
+                }
+                const endpointSchemas = metadata.schemas[method];
+                if (!endpointSchemas) throw errorFactory.newError({
+                    error: 'No schemas were found for the endpoint',
+                    statusCode: 500
+                });
+                if (endpointSchemas.query) {
+                    const queryParamsAsObject = Object.fromEntries(request.nextUrl.searchParams.entries());
+                    const queryParamsParsed = endpointSchemas.query.safeParse(queryParamsAsObject);
+                    if (!queryParamsParsed.success) throw errorFactory.newError({
+                        error: queryParamsParsed.error.message,
+                        statusCode: 400,
+                        code: "NZMT-CONTROLLER___REQUEST-PARSING",
+                        details: zod.treeifyError(queryParamsParsed.error)
+                    });
+                    requestPayload = {
+                        ...requestPayload,
+                        ...queryParamsParsed.data
+                    };
+                }
+                if (endpointSchemas.body) {
+                    const body = await request.json();
+                    const bodyParsed = endpointSchemas.body.safeParse(body);
+                    if (!bodyParsed.success) throw errorFactory.newError({
+                        error: bodyParsed.error.message,
+                        statusCode: 400,
+                        code: "NZMT-CONTROLLER___REQUEST-PARSING",
+                        details: zod.treeifyError(bodyParsed.error)
+                    });
+                    requestPayload = {
+                        ...requestPayload,
+                        ...bodyParsed.data
+                    };
+                }
+                const flags = {};
+                const result = await handler(requestPayload, {
+                    request,
+                    flags,
+                    endpointError: (payload, errorStatus, cause)=>{
+                        if ('string' == typeof payload) return errorFactory.newError({
+                            statusCode: errorStatus ?? 500,
+                            code: payload,
+                            error: payload,
+                            details: requestPayload
+                        }, cause);
+                        return errorFactory.newError({
+                            ...payload,
+                            statusCode: errorStatus ?? 500
+                        }, cause);
+                    }
+                });
+                if (endpointSchemas.response) {
+                    const resultParsed = endpointSchemas.response.safeParse(result);
+                    if (!resultParsed.success) throw errorFactory.newError({
+                        error: resultParsed.error.message,
+                        statusCode: 500,
+                        code: "NZMT-CONTROLLER___RESPONSE-PARSING",
+                        details: zod.treeifyError(resultParsed.error)
+                    });
+                    if (configuration.eventHandlers?.onSuccess) for (const onSuccessHandler of configuration.eventHandlers.onSuccess)onSuccessHandler({
+                        request,
+                        result: resultParsed.data,
+                        requestPayload: requestPayload,
+                        flags
+                    });
+                    if (configuration.customResponseLogic?.onSuccess) return await configuration.customResponseLogic.onSuccess({
+                        req: request,
+                        response: resultParsed.data
+                    });
+                    return jsonResponse(resultParsed.data, {
+                        status: 200
+                    });
+                }
+                if (configuration.eventHandlers?.onSuccess) for (const onSuccessHanlder of configuration.eventHandlers.onSuccess)await onSuccessHanlder({
+                    request,
+                    result: void 0,
+                    requestPayload: requestPayload,
+                    flags
+                });
+                if (configuration.customResponseLogic?.onSuccess) return await configuration.customResponseLogic.onSuccess({
+                    req: request,
+                    response: {}
+                });
+                return jsonResponse({}, {
+                    status: 200
+                });
+            } catch (e) {
+                let controllerError = e;
+                if (isControllerError(e)) controllerError = errorFactory.newError({
+                    error: 'Internal error',
+                    statusCode: 500
+                }, e);
+                if (!controllerError.details || 'object' != typeof controllerError.details) controllerError.details = {};
+                if (sharedConfig.onErrorHandlers) try {
+                    for (const sharedOnError of sharedConfig.onErrorHandlers)await sharedOnError({
+                        error: controllerError,
+                        req: request
+                    });
+                } catch (errorFromOnErrorHandler) {
+                    controllerError = errorFactory.newError({
+                        error: 'onError handler error',
+                        statusCode: 500
+                    }, errorFromOnErrorHandler);
+                }
+                if (configuration.eventHandlers?.onError) try {
+                    for (const onErrorHandler of configuration.eventHandlers.onError)await onErrorHandler({
+                        error: controllerError,
+                        req: request
+                    });
+                } catch (errorFromOnErrorHandler) {
+                    controllerError = errorFactory.newError({
+                        error: 'onError handler error',
+                        statusCode: 500
+                    }, errorFromOnErrorHandler);
+                }
+                if (configuration.customResponseLogic?.onError) return await configuration.customResponseLogic.onError({
+                    req: request,
+                    error: controllerError
+                });
+                return jsonResponse({
+                    message: controllerError.message,
+                    details: controllerError.statusCode.toString().startsWith('4') ? controllerError.details : null,
+                    code: controllerError.code
+                }, {
+                    status: controllerError.statusCode
+                });
+            }
+        };
+    return endpointLogic;
+};
+class Pagination {
+    data;
+    static schema = zod.object({
+        zeroBasedIndex: zod.coerce.number().int().nonnegative(),
+        pageSize: zod.coerce.number().int().positive()
+    });
+    constructor(data){
+        this.data = data;
+    }
+    static create = (data)=>{
+        const parsedModel = Pagination.schema.parse(data);
+        return new Pagination(parsedModel);
+    };
+    get model() {
+        return this.data;
+    }
+    same = (pagination)=>pagination.model.pageSize === this.model.pageSize && pagination.model.zeroBasedIndex === this.model.zeroBasedIndex;
+    get nextPage() {
+        return Pagination.create({
+            pageSize: this.data.pageSize,
+            zeroBasedIndex: this.data.zeroBasedIndex + 1
+        });
+    }
+    get previousPage() {
+        if (0 === this.model.zeroBasedIndex) return Pagination.create(this.model);
+        return Pagination.create({
+            pageSize: this.model.pageSize,
+            zeroBasedIndex: this.model.zeroBasedIndex - 1
+        });
+    }
+    get previousPage_UNSAFE() {
+        return Pagination.create({
+            pageSize: this.model.pageSize,
+            zeroBasedIndex: this.model.zeroBasedIndex - 1
+        });
+    }
+}
+const toModuleMetadata = (schemas)=>({
+        name: schemas.name,
+        schemas: {
+            ...schemas.customOperations ?? {},
+            list: {
+                payload: zod.object({
+                    filter: schemas.searchPayload.list,
+                    pagination: Pagination.schema.optional()
+                }),
+                response: zod.array(schemas.models.list)
+            },
+            details: {
+                payload: zod.object({
+                    filter: schemas.searchPayload.specific
+                }),
+                response: schemas.models.details.nullable()
+            },
+            create: {
+                payload: zod.object({
+                    payload: schemas.actionsPayload.create
+                }),
+                response: zod.object({
+                    id: zod.string()
+                })
+            },
+            updateOne: {
+                payload: zod.object({
+                    filter: schemas.searchPayload.specific,
+                    payload: schemas.actionsPayload.update
+                }),
+                response: zod.object({
+                    success: zod.boolean()
+                })
+            },
+            deleteOne: {
+                payload: zod.object({
+                    filter: schemas.searchPayload.specific
+                }),
+                response: zod.object({
+                    success: zod.boolean()
+                })
+            }
+        }
+    });
+const store_zod_utils_methods = (schemas)=>{
+    const data = toModuleMetadata(schemas);
+    return methods(data);
+};
+const InRAM = (schemas, options)=>{
+    class RAMStore {
+        ___data = [];
+        method = store_zod_utils_methods(schemas);
+        ___listSearchLogic = (entity, pattern)=>{
+            const patternKeys = Object.entries(pattern).filter(([_, value])=>!!value).map((x)=>x[0]);
+            const entityAsObject = entity;
+            return Object.entries(entityAsObject).filter(([key])=>patternKeys.includes(key)).every(([key, value])=>value === pattern[key] || value?.toString()?.includes(pattern[key]?.toString()));
+        };
+        ___specificSearchLogic = (entity, pattern)=>{
+            const patternKeys = Object.entries(pattern).filter(([_, value])=>!!value).map((x)=>x[0]);
+            const entityAsObject = entity;
+            return Object.entries(entityAsObject).filter(([key])=>patternKeys.includes(key)).every(([key, value])=>value === pattern[key] || value?.toString()?.includes(pattern[key]?.toString()));
+        };
+        ___mapDetailToList = (entity)=>entity;
+        ___mapCreatePayloadToDetail = (payload)=>({
+                ...payload,
+                id: Math.random().toString()
+            });
+        ___mapUpdatePayloadToDetail = (prevValue, rawUpdate)=>{
+            const update = Object.fromEntries(Object.entries(rawUpdate).filter(([, value])=>void 0 !== value));
+            return {
+                ...prevValue,
+                ...update
+            };
+        };
+        constructor(){
+            if (!options) return;
+            if (options.searchLogic) {
+                if (options.searchLogic.list) this.___listSearchLogic = options.searchLogic.list;
+                if (options.searchLogic.specific) this.___specificSearchLogic = options.searchLogic.specific;
+            }
+            if (options.mappers) {
+                if (options.mappers.detailToList) this.___mapDetailToList = options.mappers.detailToList;
+                if (options.mappers.createPayloadToDetail) this.___mapCreatePayloadToDetail = options.mappers.createPayloadToDetail;
+                if (options.mappers.updatePayloadToDetail) this.___mapUpdatePayloadToDetail = options.mappers.updatePayloadToDetail;
+            }
+            if (options.initialData) this.___data = [
+                ...options.initialData
+            ];
+        }
+        list = this.method('list', async ({ filter, pagination = {
+            pageSize: 1000,
+            zeroBasedIndex: 0
+        } })=>{
+            schemas.searchPayload.list.parse(filter);
+            Pagination.schema.parse(pagination);
+            const afterFiltration = this.___data.filter((x)=>this.___listSearchLogic(x, filter));
+            const afterPagination = afterFiltration.filter((_, i)=>i >= pagination.pageSize * pagination.zeroBasedIndex && i < (pagination.zeroBasedIndex + 1) * pagination.pageSize);
+            const result = afterPagination.map((x)=>this.___mapDetailToList(x));
+            zod.array(schemas.models.list).parse(result);
+            return result;
+        });
+        details = this.method('details', async ({ filter })=>{
+            const details = this.___data.find((x)=>this.___specificSearchLogic(x, filter));
+            if (!details) return null;
+            return details;
+        });
+        create = this.method('create', async ({ payload })=>{
+            const newItem = this.___mapCreatePayloadToDetail(payload);
+            this.___data = this.___data.concat(newItem);
+            return {
+                id: newItem.id
+            };
+        });
+        updateOne = this.method('updateOne', async ({ filter, payload })=>{
+            const index = this.___data.findIndex((x)=>this.___specificSearchLogic(x, filter));
+            this.___data = this.___data.map((x, i)=>{
+                if (i !== index) return x;
+                return this.___mapUpdatePayloadToDetail(x, payload);
+            });
+            return {
+                success: index > -1
+            };
+        });
+        deleteOne = this.method('deleteOne', async ({ filter })=>{
+            const index = this.___data.findIndex((x)=>this.___specificSearchLogic(x, filter));
+            this.___data = this.___data.filter((_x, i)=>i !== index);
+            return {
+                success: index > -1
+            };
+        });
+    }
+    return RAMStore;
+};
+export { store_namespaceObject as Store, value_objects_namespaceObject as ValueObjects, zod_controller_utils_namespaceObject as Controller, zod_module_utils_namespaceObject as Module };

package/dist/store/index.d.ts

@@ -0,0 +1,3 @@
+export { type Types } from './store.shared-models.utils';
+export * from './store.zod.utils';
+export * from './store.ram.utils';

package/dist/store/store.ram.spec.d.ts

@@ -0,0 +1 @@
+export {};