@alevnyacow/nzmt 0.1.3 → 0.1.5

package/README.md

@@ -25,6 +25,99 @@
 
 ## <a id='module'></a>Module
 
+### methods
+
+Returns zod module method generator. 
+
+1. How to make a method generator:
+
+```ts
+import { Module } from '@alevnyacow/nzmt'
+
+const mathServiceMethods = Module.methods({
+    // Service name, will be used in errors
+    name: 'MathService', 
+    // Method schemas description
+    schemas: {
+        // Method `basicOperations`
+        basicOperation: {
+            // `basicOperations` payload (Zod schema)
+            payload: z.object({     
+                lhs: z.number(), 
+                rhs: z.number(),
+                operation: z.enum(['+', '-', '/', '*'])
+            }),
+            // `basicOperations` response (Zod schema)
+            response: z.object({ 
+                result: z.number() 
+            })
+        },
+        // ...another methods
+    } 
+})
+```
+
+2. How to use this generator (example with class, you can use it also without classes):
+
+```ts
+export class MathService {
+    // created generator
+    private methods = mathServiceMethods
+
+    public DIVIDED_BY_ZERO = 'DIVIDED_BY_ZERO'
+
+    public basicMathOperation = this.methods(
+        // Method name, working TS intellisense
+        'basicOperation',
+        // handler logic
+        async (
+            // payload, also with TS intellisense
+            { lhs, operation, rhs },
+            // errors generator
+            { methodError }
+        ) => {
+            switch(operation) {
+                case '*': {
+                    // all types are infered from schemas, so
+                    // TS intellisense also works with return types 
+                    return { result: lhs * rhs }
+                }
+                case '+': {
+                    return { result: lhs + rhs }
+                }
+                case '-': {
+                    return { result: lhs - rhs }
+                }
+                case '/': {
+                    if (rhs === 0) {
+                        /**
+                         * You can create error with just code. All
+                         * metadata like method name, zod module name
+                         * or payload will present in this error object.
+                         */ 
+                        throw methodError(DIVIDED_BY_ZERO)
+                    }
+                    return { result: lhs / rhs }
+                }
+            }
+        }
+    )
+}
+```
+
+3. How to use zod module:
+
+```ts
+const mathService = new MathService();
+
+// types infered from zod schemas, working intellisense
+const { result } = mathService.basicMathOperation({
+    lhs: 10,
+    rhs: 15,
+    operation: '+'
+})
+```
+
 ## <a id='controller'></a>Controller
 
 ## <a id='store'></a>Store

package/bin/cli.js

@@ -128,7 +128,7 @@ function generateStores(lowerCase, upperCase) {
         "",
         "\tactionsPayload: {",
         config?.paths?.entities ? `\t\tcreate: ${upperCase}.schema.omit({ id: true }),` : "\t\tcreate: z.object({ }),",
-        config?.paths?.entities ? `\t\tupdate: ${upperCase}.schema.omit({ id: true }),` : "\t\tupdate: z.object({ }),",
+        config?.paths?.entities ? `\t\tupdate: ${upperCase}.schema.omit({ id: true }).partial(),` : "\t\tupdate: z.object({ }),",
         "\t},",
         "",
         `\tname: '${upperCase}Store'`,

package/dist/index.cjs

@@ -163,7 +163,7 @@ const methods = (metadata, sharedConfig = {})=>(methodName, handler, config = {}
                     methodError: (payload, cause)=>ErrorFactory.forModule(name).inMethod(methodName).newError('string' == typeof payload ? {
                             error: payload,
                             code: payload,
-                            details: payload
+                            details: parsedPayload
                         } : payload, cause)
                 });
                 const parsedResponse = schemas[methodName].response.parse(response);

package/dist/index.js

@@ -127,7 +127,7 @@ const methods = (metadata, sharedConfig = {})=>(methodName, handler, config = {}
                     methodError: (payload, cause)=>ErrorFactory.forModule(name).inMethod(methodName).newError('string' == typeof payload ? {
                             error: payload,
                             code: payload,
-                            details: payload
+                            details: parsedPayload
                         } : payload, cause)
                 });
                 const parsedResponse = schemas[methodName].response.parse(response);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alevnyacow/nzmt",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Next Zod Modules Toolkit",
   "repository": {
     "type": "git",