@alevnyacow/nzmt 0.0.21 → 0.0.23

package/bin/cli.js

@@ -7,6 +7,10 @@ var args = process.argv.slice(2);
 var [command, entityName] = args;
 
 function camelizeVariants(str) {
+    if (!str.includes('-')) {
+        return [str, str.substring(0, 1).toUpperCase() + str.substring(1)]
+    }
+
   const words = str.split("-");
 
   const lowerCamel = words
@@ -97,28 +101,29 @@ function generateStores(lowerCase, upperCase) {
     fs.writeFileSync(path.resolve(folder, `${entityName}.store.ts`), [
         "import z from 'zod'",
         "import { Store } from '@alevnyacow/nzmt'",
+        config?.paths?.entities ? `import ${upperCase} from ${config?.paths?.entities.replace('./src', '@')}/${entityName}` : undefined,
         "",
         `export const ${lowerCase}StoreMetadata = {`,
         "\tmodels: {",
-        "\t\tlist: z.object({ }),",
-        "\t\tdetails: z.object({ }),",
+        config?.paths?.entities ? `\t\tlist: ${upperCase}.schema,` : "\t\tlist: z.object({ }),",
+        config?.paths?.entities ? `\t\tdetails: ${upperCase}.schema,` : "\t\tdetails: z.object({ }),",
         "\t},",
         "",
         "\tsearchPayload: {",
-        "\t\tlist: z.object({ }),",
-        "\t\tspecific: z.object({ }),",
+        config?.paths?.entities ? `\t\tlist: ${upperCase}.schema.omit({ id: true }),` : "\t\tlist: z.object({ }),",
+        config?.paths?.entities ? `\t\tspecific: ${upperCase}.schema.pick({ id: true }),` : "\t\tspecific: z.object({ }),",
         "\t},",
         "",
         "\tactionsPayload: {",
-        "\t\tcreate: z.object({ }),",
-        "\t\tupdate: z.object({ }),",
+        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({ }),",
         "\t},",
         "",
         `\tname: '${upperCase}Store'`,
         "} satisfies Store.Metadata",
         "",
         `export type ${upperCase}Store = Store.Contract<typeof ${lowerCase}StoreMetadata>`
-    ].join('\n'))
+    ].filter(x => typeof x === 'string').join('\n'))
 
     // RAM
 
@@ -250,7 +255,6 @@ function generateStores(lowerCase, upperCase) {
         `export * from './${entityName}.store.prisma.ts'`,
         `export * from './${entityName}.store.ram.ts'`
     ].join('\n'))
-
 }
 
 if (command === 'store') {
@@ -259,3 +263,42 @@ if (command === 'store') {
     process.exit(0);
 }
 
+function generateEntity(upperCase) {
+    const folder = config?.paths?.entities ? path.resolve(process.cwd(), config?.paths?.entities, entityName) : path.resolve(process.cwd(), entityName);
+
+    fs.mkdirSync(folder, { recursive: true })
+
+    const body = [
+        "import z from 'zod'",
+        "import { Entities } from '@alevnyacow/nzmt'",
+        "",
+        `export type ${upperCase}Model = z.infer<typeof ${upperCase}.schema>`,
+        "",
+        `export class ${upperCase} {`,
+        "\tstatic schema = z.object({",
+        "\t\tid: Entities.Identifier.schema,",
+        "\t\t",
+        "\t})",
+        "\t",
+        `\tprivate constructor(private readonly data: ${upperCase}Model) {}`,
+        "\t",
+        `\tstatic create = (data: ${upperCase}Model) => {`,
+        `\t\tconst parsedModel = ${upperCase}.schema.parse(data)`,
+        `\t\treturn new ${upperCase}(parsedModel)`,
+        "\t}",
+        "\t",
+        `\tget model(): ${upperCase}Model {`,
+        "\t\treturn this.data",
+        "\t}",
+        "}"
+    ].join('\n')
+
+    fs.writeFileSync(path.resolve(folder, `${entityName}.entity.ts`), body)
+    fs.writeFileSync(path.resolve(folder, 'index.ts'), `export * from './${entityName}.entity'`)
+}
+
+if (command === 'entity') {
+    var [lowerCase, upperCase] = camelizeVariants(entityName)
+    generateEntity(upperCase)
+    process.exit(0)
+}

package/dist/entities/identifier.entity.d.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+export type IdentifierModel = z.infer<typeof Identifier.schema>;
+export declare class Identifier {
+    private readonly data;
+    static schema: z.ZodString;
+    private constructor();
+    static create: (data: IdentifierModel) => Identifier;
+    static get randomUUID(): Identifier;
+    get model(): IdentifierModel;
+    get isUUID(): boolean;
+}

package/dist/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './identifier.entity';
+export * from './pagination.entity';

package/dist/index.cjs

@@ -35,7 +35,8 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Controller: ()=>zod_controller_utils_namespaceObject,
     Store: ()=>store_namespaceObject,
-    Module: ()=>zod_module_utils_namespaceObject
+    Module: ()=>zod_module_utils_namespaceObject,
+    Entities: ()=>entities_namespaceObject
 });
 var zod_module_utils_namespaceObject = {};
 __webpack_require__.r(zod_module_utils_namespaceObject);
@@ -54,6 +55,12 @@ __webpack_require__.d(store_namespaceObject, {
     InRAM: ()=>InRAM,
     methods: ()=>store_zod_utils_methods
 });
+var entities_namespaceObject = {};
+__webpack_require__.r(entities_namespaceObject);
+__webpack_require__.d(entities_namespaceObject, {
+    Identifier: ()=>Identifier,
+    Pagination: ()=>Pagination
+});
 class ErrorFactory {
     static isControllerError = (error)=>{
         if (!error || 'object' != typeof error) return false;
@@ -505,11 +512,31 @@ const InRAM = (schemas, options)=>{
     }
     return RAMStore;
 };
+const external_node_crypto_namespaceObject = require("node:crypto");
+class Identifier {
+    data;
+    static schema = external_zod_default().string().nonempty();
+    constructor(data){
+        this.data = data;
+    }
+    static create = (data)=>new Identifier(Identifier.schema.parse(data));
+    static get randomUUID() {
+        return Identifier.create((0, external_node_crypto_namespaceObject.randomUUID)());
+    }
+    get model() {
+        return this.data;
+    }
+    get isUUID() {
+        return external_zod_default().uuidv4().safeParse(this.data).success;
+    }
+}
 exports.Controller = __webpack_exports__.Controller;
+exports.Entities = __webpack_exports__.Entities;
 exports.Module = __webpack_exports__.Module;
 exports.Store = __webpack_exports__.Store;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "Controller",
+    "Entities",
     "Module",
     "Store"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * as Module from './zod-module.utils';
 export * as Controller from './zod-controller.utils';
 export * as Store from './store';
+export * as Entities from './entities';

package/dist/index.js

@@ -1,6 +1,13 @@
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { NextResponse } from "next/server";
 import zod from "zod";
+import { randomUUID } from "node:crypto";
+var entities_namespaceObject = {};
+__webpack_require__.r(entities_namespaceObject);
+__webpack_require__.d(entities_namespaceObject, {
+    Identifier: ()=>Identifier,
+    Pagination: ()=>Pagination
+});
 var store_namespaceObject = {};
 __webpack_require__.r(store_namespaceObject);
 __webpack_require__.d(store_namespaceObject, {
@@ -466,4 +473,21 @@ const InRAM = (schemas, options)=>{
     }
     return RAMStore;
 };
-export { store_namespaceObject as Store, zod_controller_utils_namespaceObject as Controller, zod_module_utils_namespaceObject as Module };
+class Identifier {
+    data;
+    static schema = zod.string().nonempty();
+    constructor(data){
+        this.data = data;
+    }
+    static create = (data)=>new Identifier(Identifier.schema.parse(data));
+    static get randomUUID() {
+        return Identifier.create(randomUUID());
+    }
+    get model() {
+        return this.data;
+    }
+    get isUUID() {
+        return zod.uuidv4().safeParse(this.data).success;
+    }
+}
+export { entities_namespaceObject as Entities, store_namespaceObject as Store, zod_controller_utils_namespaceObject as Controller, zod_module_utils_namespaceObject as Module };

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

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { Pagination } from './store.pagination.entity';
+import { Pagination } from '../entities/pagination.entity';
 import type { CRUD, Types } from './store.shared-models.utils';
 import { type Contract, type Metadata } from './store.zod.utils';
 export declare const InRAM: <T extends Metadata>(schemas: T, options?: {
@@ -741,7 +741,7 @@ export declare const InRAM: <T extends Metadata>(schemas: T, options?: {
                     update: AUpdate;
                 };
             } : never : never : never)["SearchPayload"]["list"];
-            pagination?: import("./store.pagination.entity").PaginationModel;
+            pagination?: import("../entities").PaginationModel;
         }) => Promise<(Contract<T> extends infer T_2 ? T_2 extends Contract<T> ? T_2 extends {
             list: (data: {
                 filter: infer SList;

package/dist/store/store.shared-models.utils.d.ts

@@ -1,4 +1,4 @@
-import type { PaginationModel } from './store.pagination.entity';
+import type { PaginationModel } from '../entities/pagination.entity';
 export type CRUD<Models extends {
     list: unknown;
     detail: unknown;

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

@@ -1,6 +1,6 @@
 import type { ZodArray, ZodBoolean, ZodObject, ZodString, ZodType, ZodUnion } from 'zod';
 import z from 'zod';
-import { Pagination } from './store.pagination.entity';
+import { Pagination } from '../entities/pagination.entity';
 import type { CRUD } from './store.shared-models.utils';
 type ZodSchema = ZodType;
 type Models<List, Detail> = {

package/package.json

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