@alevnyacow/nzmt 0.0.19 → 0.0.21

package/bin/cli.js

@@ -6,6 +6,22 @@ var args = process.argv.slice(2);
 
 var [command, entityName] = args;
 
+function camelizeVariants(str) {
+  const words = str.split("-");
+
+  const lowerCamel = words
+    .map((word, index) => 
+      index === 0 ? word.toLowerCase() : word[0].toUpperCase() + word.slice(1).toLowerCase()
+    )
+    .join("");
+
+  const upperCamel = words
+    .map(word => word[0].toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+
+  return [lowerCamel, upperCamel];
+}
+
 function findProjectRoot(startDir = process.cwd()) {
   let dir = startDir;
   while (dir !== path.parse(dir).root) {
@@ -40,7 +56,7 @@ function loadConfig() {
 
 const config = loadConfig();
 
-if (command === 'init-config') {
+function createDefaultConfig() {
     if (!config) {
         const projectRoot = findProjectRoot()
         if (!projectRoot) {
@@ -56,34 +72,22 @@ if (command === 'init-config') {
                 stores: './src/backend/stores',
                 services: './src/backend/services',
                 providers: './src/backend/providers',
-                controllers: './src/backend/controllers'
+                controllers: './src/backend/controllers',
+                entities: './src/shared/entities',
+                queries: './src/client/shared/queries'
             },
             dependencyInjection: 'inversifyjs'
         }, null, '\t'))
     }
 
-    process.exit(0);
 }
 
-function camelizeVariants(str) {
-  const words = str.split("-");
-
-  const lowerCamel = words
-    .map((word, index) => 
-      index === 0 ? word.toLowerCase() : word[0].toUpperCase() + word.slice(1).toLowerCase()
-    )
-    .join("");
-
-  const upperCamel = words
-    .map(word => word[0].toUpperCase() + word.slice(1).toLowerCase())
-    .join("");
-
-  return [lowerCamel, upperCamel];
+if (command === 'init-config') {
+    createDefaultConfig()
+    process.exit(0)
 }
 
-var [lowerCase, upperCase] = camelizeVariants(entityName)
-
-if (command === 'store') {
+function generateStores(lowerCase, upperCase) {
     const folder = config?.paths?.stores ? path.resolve(process.cwd(), config?.paths?.stores, entityName) : path.resolve(process.cwd(), entityName);
 
     fs.mkdirSync(folder, { recursive: true })
@@ -246,5 +250,12 @@ if (command === 'store') {
         `export * from './${entityName}.store.prisma.ts'`,
         `export * from './${entityName}.store.ram.ts'`
     ].join('\n'))
+
+}
+
+if (command === 'store') {
+    var [lowerCase, upperCase] = camelizeVariants(entityName)
+    generateStores(lowerCase, upperCase)
+    process.exit(0);
 }
 

package/dist/index.cjs

@@ -35,7 +35,12 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Controller: ()=>zod_controller_utils_namespaceObject,
     Store: ()=>store_namespaceObject,
-    zodModuleMethodFactory: ()=>zodModuleMethodFactory
+    Module: ()=>zod_module_utils_namespaceObject
+});
+var zod_module_utils_namespaceObject = {};
+__webpack_require__.r(zod_module_utils_namespaceObject);
+__webpack_require__.d(zod_module_utils_namespaceObject, {
+    methods: ()=>methods
 });
 var zod_controller_utils_namespaceObject = {};
 __webpack_require__.r(zod_controller_utils_namespaceObject);
@@ -47,7 +52,7 @@ var store_namespaceObject = {};
 __webpack_require__.r(store_namespaceObject);
 __webpack_require__.d(store_namespaceObject, {
     InRAM: ()=>InRAM,
-    methods: ()=>methods
+    methods: ()=>store_zod_utils_methods
 });
 class ErrorFactory {
     static isControllerError = (error)=>{
@@ -142,7 +147,7 @@ class ErrorFactory {
         });
     };
 }
-const zodModuleMethodFactory = (metadata, sharedConfig = {})=>(methodName, handler, config = {})=>{
+const methods = (metadata, sharedConfig = {})=>(methodName, handler, config = {})=>{
         const { name, schemas } = metadata;
         return async (payload)=>{
             try {
@@ -414,14 +419,14 @@ const mapStoreSchemasToModuleMetadata = (schemas, name)=>({
             }
         }
     });
-const methods = (schemas)=>{
+const store_zod_utils_methods = (schemas)=>{
     const data = mapStoreSchemasToModuleMetadata(schemas, schemas.name);
-    return zodModuleMethodFactory(data);
+    return methods(data);
 };
 const InRAM = (schemas, options)=>{
     class RAMStore {
         ___data = [];
-        method = methods(schemas);
+        method = store_zod_utils_methods(schemas);
         ___listSearchLogic = (entity, pattern)=>{
             const patternKeys = Object.entries(pattern).filter(([_, value])=>!!value).map((x)=>x[0]);
             const entityAsObject = entity;
@@ -501,12 +506,12 @@ const InRAM = (schemas, options)=>{
     return RAMStore;
 };
 exports.Controller = __webpack_exports__.Controller;
+exports.Module = __webpack_exports__.Module;
 exports.Store = __webpack_exports__.Store;
-exports.zodModuleMethodFactory = __webpack_exports__.zodModuleMethodFactory;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "Controller",
-    "Store",
-    "zodModuleMethodFactory"
+    "Module",
+    "Store"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { zodModuleMethodFactory } from './zod-module.utils';
+export * as Module from './zod-module.utils';
 export * as Controller from './zod-controller.utils';
 export * as Store from './store';

package/dist/index.js

@@ -5,7 +5,7 @@ var store_namespaceObject = {};
 __webpack_require__.r(store_namespaceObject);
 __webpack_require__.d(store_namespaceObject, {
     InRAM: ()=>InRAM,
-    methods: ()=>methods
+    methods: ()=>store_zod_utils_methods
 });
 var zod_controller_utils_namespaceObject = {};
 __webpack_require__.r(zod_controller_utils_namespaceObject);
@@ -13,6 +13,11 @@ __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
+});
 class ErrorFactory {
     static isControllerError = (error)=>{
         if (!error || 'object' != typeof error) return false;
@@ -106,7 +111,7 @@ class ErrorFactory {
         });
     };
 }
-const zodModuleMethodFactory = (metadata, sharedConfig = {})=>(methodName, handler, config = {})=>{
+const methods = (metadata, sharedConfig = {})=>(methodName, handler, config = {})=>{
         const { name, schemas } = metadata;
         return async (payload)=>{
             try {
@@ -375,14 +380,14 @@ const mapStoreSchemasToModuleMetadata = (schemas, name)=>({
             }
         }
     });
-const methods = (schemas)=>{
+const store_zod_utils_methods = (schemas)=>{
     const data = mapStoreSchemasToModuleMetadata(schemas, schemas.name);
-    return zodModuleMethodFactory(data);
+    return methods(data);
 };
 const InRAM = (schemas, options)=>{
     class RAMStore {
         ___data = [];
-        method = methods(schemas);
+        method = store_zod_utils_methods(schemas);
         ___listSearchLogic = (entity, pattern)=>{
             const patternKeys = Object.entries(pattern).filter(([_, value])=>!!value).map((x)=>x[0]);
             const entityAsObject = entity;
@@ -461,4 +466,4 @@ const InRAM = (schemas, options)=>{
     }
     return RAMStore;
 };
-export { store_namespaceObject as Store, zodModuleMethodFactory, zod_controller_utils_namespaceObject as Controller };
+export { store_namespaceObject as Store, zod_controller_utils_namespaceObject as Controller, zod_module_utils_namespaceObject as Module };

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

@@ -364,7 +364,7 @@ export declare const InRAM: <T extends Metadata>(schemas: T, options?: {
                     success: z.ZodBoolean;
                 }, z.core.$strip>;
             };
-        })[Method]["response"]>>, config?: import("../zod-module.utils").ZodModuleConfig) => (payload: z.core.output<(Record<Exclude<keyof (T["customOperations"] extends Record<string, {
+        })[Method]["response"]>>, config?: import("../zod-module.utils").Config) => (payload: z.core.output<(Record<Exclude<keyof (T["customOperations"] extends Record<string, {
             payload: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
             response: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
         }> ? { [operation in keyof T["customOperations"]]: {

package/dist/store/store.zod.utils.d.ts

@@ -261,7 +261,7 @@ export declare const methods: <T extends Metadata>(schemas: T) => <Method extend
             success: ZodBoolean;
         }, z.core.$strip>;
     };
-})[Method]["response"]>>, config?: import("../zod-module.utils").ZodModuleConfig) => (payload: z.core.output<(Record<Exclude<keyof (T["customOperations"] extends Record<string, {
+})[Method]["response"]>>, config?: import("../zod-module.utils").Config) => (payload: z.core.output<(Record<Exclude<keyof (T["customOperations"] extends Record<string, {
     payload: ZodSchema;
     response: ZodSchema;
 }> ? { [operation in keyof T["customOperations"]]: {

package/dist/zod-controller.utils.d.ts

@@ -12,8 +12,8 @@ type ZodAPISchemas = {
     response?: ZodObject;
 };
 type ErrorResponse = {
-    message: string;
-    code?: string;
+    code: string;
+    message?: string;
     details?: any;
 };
 type EndpointErrorGenerator = (payload: string | ErrorBaseCreatingPayload, errorStatus?: number, cause?: unknown) => ControllerErrorModel;

package/dist/zod-module.utils.d.ts

@@ -17,13 +17,13 @@ export type DTOs<T extends Metadata> = {
 export type Methods<T extends Metadata> = {
     [K in keyof T['schemas']]: (payload: z.infer<T['schemas'][K]['payload']>) => Promise<z.infer<T['schemas'][K]['response']>>;
 };
-export type ZodModuleConfig = {
+export type Config = {
     onError?: (e: ModuleErrorModel) => Promise<void>;
 };
-export declare const zodModuleMethodFactory: <T extends Schemas>(metadata: {
+export declare const methods: <T extends Schemas>(metadata: {
     schemas: T;
     name: string;
-}, sharedConfig?: ZodModuleConfig) => <Method extends keyof T>(methodName: Method, handler: (payload: z.infer<T[Method]["payload"]>, config: {
+}, sharedConfig?: Config) => <Method extends keyof T>(methodName: Method, handler: (payload: z.infer<T[Method]["payload"]>, config: {
     methodError: (payload: string | ErrorBaseCreatingPayload, cause?: unknown) => ModuleErrorModel;
-}) => Promise<z.infer<T[Method]["response"]>>, config?: ZodModuleConfig) => (payload: z.infer<T[Method]["payload"]>) => Promise<z.infer<T[Method]["response"]>>;
+}) => Promise<z.infer<T[Method]["response"]>>, config?: Config) => (payload: z.infer<T[Method]["payload"]>) => Promise<z.infer<T[Method]["response"]>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alevnyacow/nzmt",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "Next Zod Modules Toolkit",
   "type": "module",
   "exports": {