@alevnyacow/nzmt 0.5.0 → 0.6.0

package/bin/cli.js

@@ -91,25 +91,39 @@ function createDefaultConfig() {
             throw 'No package.json was found'
         }
 
-        fs.writeFileSync(path.resolve(projectRoot, 'nzmt.config.json'), JSON.stringify({
+        const prismaClientPathOption = [entityName, ...options].find(x => x.startsWith('prismaClientPath:')) 
+
+        let prismaClientPath = prismaClientPathOption ? prismaClientPathOption.split(':')[1] : undefined
+
+        fs.writeFileSync(path.resolve(projectRoot, 'nzmt.config.json'), JSON.stringify(prismaClientPath ? {
             paths: {
                 di: './src/server/di',
                 stores: './src/server/stores',
                 services: './src/server/services',
                 providers: './src/server/providers',
                 controllers: './src/server/controllers',
+                infrastructure: './src/server/infrastructure',
                 entities: './src/shared/entities',
                 valueObjects: './src/shared/value-objects',
-                queries: './src/client/shared/queries'
+                queries: './src/client/shared/queries',
             },
             store: {
                 prisma: {
-                    import: [
-                        "import { prisma } from '@/server/infrastructure/prisma'",
-                        "import type { Prisma } from '@/server/generated-prisma/client'",
-                    ]
+                    clientPath: prismaClientPath
                 },
             }
+        } : {
+            paths: {
+                di: './src/server/di',
+                stores: './src/server/stores',
+                services: './src/server/services',
+                providers: './src/server/providers',
+                controllers: './src/server/controllers',
+                infrastructure: './src/server/infrastructure',
+                entities: './src/shared/entities',
+                valueObjects: './src/shared/value-objects',
+                queries: './src/client/shared/queries',
+            }
         }, null, '\t'))
     }
 }
@@ -267,9 +281,52 @@ function initDI() {
     ].join('\n'))
 };
 
+function initPrisma() {
+    const config = loadConfig()
+    const prismaClientPath = config?.store?.prisma?.clientPath
+    if (!prismaClientPath) {
+        return
+    }
+    const prismaFolder = path.resolve(process.cwd(), config?.paths?.infrastructure, 'prisma')
+    fs.mkdirSync(prismaFolder, { recursive: true })
+
+    fs.writeFileSync(path.resolve(prismaFolder, 'client.ts'), [
+        `import { PrismaPg } from '@prisma/adapter-pg'`,
+        `import { PrismaClient } from '${prismaClientPath}'`,
+        ``,
+        `const adapter = new PrismaPg({`,
+        `\tconnectionString: process.env.DATABASE_URL`,
+        `})`,
+        ``,
+        `export const prismaClient = new PrismaClient({ adapter })`
+    ].join('\n'))
+
+    fs.writeFileSync(path.resolve(prismaFolder, 'index.ts'), [
+        `export * from './client'`
+    ].join('\n'))
+
+    // Update DI
+
+    const diEntriesPath = path.resolve(process.cwd(), config?.paths?.di, 'entries.di.ts')
+
+    insertBeforeLineInFile(
+        diEntriesPath,
+        'type DIEntries =',
+        `import { prismaClient } from '${config?.paths?.infrastructure.replace('./src', '@')}/prisma'\n`
+    )
+
+    insertAfterLineInFile(
+        diEntriesPath,
+        '// Other',
+        `\tPrismaClient: { constantValue: prismaClient },`,
+    )
+}
+
 if (command.toLowerCase() === 'init' || command === 'i') {
     createDefaultConfig()
     initDI()
+    initPrisma()
+
     process.exit(0)
 }
 
@@ -324,120 +381,126 @@ function generateStores(lowerCase, upperCase, withEntityPreset) {
     ].filter(x => typeof x === 'string').join('\n'))
 
     // Prisma
+    const prismaPath = config.store?.prisma?.clientPath
+    if (prismaPath) {
+        fs.writeFileSync(path.resolve(folder, `${entityName}.store.prisma.ts`), [
+            `import type { Prisma, PrismaClient } from '${prismaPath}'`,
+            `import { DITokens } from '${config?.paths?.di?.replace('./src', '@')}'`,
+            "import { injectable } from 'inversify'",
+            "import { Store } from '@alevnyacow/nzmt'",
+            `import { type ${upperCase}Store, ${lowerCase}StoreMetadata } from './${entityName}.store'`,
+            "",
+            `type Types = Store.Types<${upperCase}Store>`,
+            "",
+            "const mappers = {",
+            `\ttoFindOnePayload: (source: Types['findOnePayload']): Prisma.${upperCase}WhereUniqueInput => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t},",
+            `\ttoFindListPayload: (source: Types['findListPayload']): Prisma.${upperCase}WhereInput => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t},",
+            `\ttoListModel: (source: Prisma.${upperCase}GetPayload<{}>): Types['listModel'] => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t},",
+            `\ttoDetails: (source: Prisma.${upperCase}GetPayload<{ include: { } }>): Types['details'] => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t},",
+            `\ttoCreatePayload: (source: Types['createPayload']): Prisma.${upperCase}CreateInput => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t},",
+            `\ttoUpdatePayload: (source: Types['updatePayload']): Prisma.${upperCase}UpdateInput => {`,
+            "\t\treturn {",
+            "\t\t\t",
+            "\t\t};",
+            "\t}",
+            "}",
+            "",
+            "@injectable()",
+            `export class ${upperCase}PrismaStore implements ${upperCase}Store {`,
+            `\tprivate method = Store.methods(${lowerCase}StoreMetadata);`,
+            "",
+            "\tconstructor(@inject('PrismaClient' satisfies DITokens) private readonly prismaClient: PrismaClient) {}",
+            "",
+            "\tlist = this.method('list', async ({ filter, pagination: { pageSize, zeroBasedIndex } = { pageSize: 1000, zeroBasedIndex: 0 }}) => {",
+            `\t\tconst list = await this.prismaClient.${lowerCase}.findMany({`,
+            "\t\t\twhere: mappers.toFindListPayload(filter),",
+            "\t\t\tskip: zeroBasedIndex * pageSize,",
+            "\t\t\ttake: pageSize",
+            "\t\t})",
+            "\t\t",
+            "\t\treturn list.map(mappers.toListModel)",
+            "\t});",
+            "",
+            "\tdetails = this.method('details', async ({ filter }) => {",
+            `\t\tconst details = await this.prismaClient.${lowerCase}.findUnique({`,
+            "\t\t\twhere: mappers.toFindOnePayload(filter),",
+            "\t\t\tinclude: {}",
+            "\t\t})",
+            "",
+            "\t\tif (!details) {",
+            "\t\t\treturn null",
+            "\t\t}",
+            "",
+            "\t\treturn mappers.toDetails(details)",
+            "\t});",
+            "",
+            "\tcreate = this.method('create', async ({ payload }) => {",
+            `\t\tconst { id } = await this.prismaClient.${lowerCase}.create({`,
+            "\t\t\tdata: mappers.toCreatePayload(payload),",
+            "\t\t\tselect: { id: true }",
+            "\t\t})",
+            "",
+            "\t\treturn { id }",
+            "\t});",
+            "",
+            "\tupdateOne = this.method('updateOne', async ({ filter, payload }) => {",
+            "\t\ttry {",
+            `\t\t\tawait this.prismaClient.${lowerCase}.update({`,
+            "\t\t\t\twhere: mappers.toFindOnePayload(filter),",
+            "\t\t\t\tdata: mappers.toUpdatePayload(payload),",
+            "\t\t\t})",
+            "",
+            "\t\t\treturn { success: true }",
+            "\t\t}",
+            "\t\tcatch {",
+            "\t\t\treturn { success: false }",
+            "\t\t}",
+            "\t});",
+            "",
+            "\tdeleteOne = this.method('deleteOne', async ({ filter }) => {",
+            "\t\ttry {",
+            `\t\t\tawait this.prismaClient.${lowerCase}.delete({`,
+            "\t\t\t\twhere: mappers.toFindOnePayload(filter),",
+            "\t\t\t})",
+            "",
+            "\t\t\treturn { success: true }",
+            "\t\t}",
+            "\t\tcatch {",
+            "\t\t\treturn { success: false }",
+            "\t\t}",
+            "\t});",
+            "};"
+        ].filter(x => typeof x === 'string').join('\n'))
+    }
 
-    fs.writeFileSync(path.resolve(folder, `${entityName}.store.prisma.ts`), [
-        ...config?.store?.prisma?.import ?? [],
-        "import { injectable } from 'inversify'",
-        "import { Store } from '@alevnyacow/nzmt'",
-        `import { type ${upperCase}Store, ${lowerCase}StoreMetadata } from './${entityName}.store'`,
-        "",
-        `type Types = Store.Types<${upperCase}Store>`,
-        "",
-        "const mappers = {",
-        `\ttoFindOnePayload: (source: Types['findOnePayload']): Prisma.${upperCase}WhereUniqueInput => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t},",
-        `\ttoFindListPayload: (source: Types['findListPayload']): Prisma.${upperCase}WhereInput => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t},",
-        `\ttoListModel: (source: Prisma.${upperCase}GetPayload<{}>): Types['listModel'] => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t},",
-        `\ttoDetails: (source: Prisma.${upperCase}GetPayload<{ include: { } }>): Types['details'] => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t},",
-        `\ttoCreatePayload: (source: Types['createPayload']): Prisma.${upperCase}CreateInput => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t},",
-        `\ttoUpdatePayload: (source: Types['updatePayload']): Prisma.${upperCase}UpdateInput => {`,
-        "\t\treturn {",
-        "\t\t\t",
-        "\t\t};",
-        "\t}",
-        "}",
-        "",
-        "@injectable()",
-        `export class ${upperCase}PrismaStore implements ${upperCase}Store {`,
-        `\tprivate method = Store.methods(${lowerCase}StoreMetadata);`,
-        "",
-        "\tlist = this.method('list', async ({ filter, pagination: { pageSize, zeroBasedIndex } = { pageSize: 1000, zeroBasedIndex: 0 }}) => {",
-        `\t\tconst list = await prisma.${lowerCase}.findMany({`,
-        "\t\t\twhere: mappers.toFindListPayload(filter),",
-        "\t\t\tskip: zeroBasedIndex * pageSize,",
-        "\t\t\ttake: pageSize",
-        "\t\t})",
-        "\t\t",
-        "\t\treturn list.map(mappers.toListModel)",
-        "\t});",
-        "",
-        "\tdetails = this.method('details', async ({ filter }) => {",
-        `\t\tconst details = await prisma.${lowerCase}.findUnique({`,
-        "\t\t\twhere: mappers.toFindOnePayload(filter),",
-        "\t\t\tinclude: {}",
-        "\t\t})",
-        "",
-        "\t\tif (!details) {",
-        "\t\t\treturn null",
-        "\t\t}",
-        "",
-        "\t\treturn mappers.toDetails(details)",
-        "\t});",
-        "",
-        "\tcreate = this.method('create', async ({ payload }) => {",
-        `\t\tconst { id } = await prisma.${lowerCase}.create({`,
-        "\t\t\tdata: mappers.toCreatePayload(payload),",
-        "\t\t\tselect: { id: true }",
-        "\t\t})",
-        "",
-        "\t\treturn { id }",
-        "\t});",
-        "",
-        "\tupdateOne = this.method('updateOne', async ({ filter, payload }) => {",
-        "\t\ttry {",
-        `\t\t\tawait prisma.${lowerCase}.update({`,
-        "\t\t\t\twhere: mappers.toFindOnePayload(filter),",
-        "\t\t\t\tdata: mappers.toUpdatePayload(payload),",
-        "\t\t\t})",
-        "",
-        "\t\t\treturn { success: true }",
-        "\t\t}",
-        "\t\tcatch {",
-        "\t\t\treturn { success: false }",
-        "\t\t}",
-        "\t});",
-        "",
-        "\tdeleteOne = this.method('deleteOne', async ({ filter }) => {",
-        "\t\ttry {",
-        `\t\t\tawait prisma.${lowerCase}.delete({`,
-        "\t\t\t\twhere: mappers.toFindOnePayload(filter),",
-        "\t\t\t})",
-        "",
-        "\t\t\treturn { success: true }",
-        "\t\t}",
-        "\t\tcatch {",
-        "\t\t\treturn { success: false }",
-        "\t\t}",
-        "\t});",
-        "};"
-    ].filter(x => typeof x === 'string').join('\n'))
 
     // barrel
 
     fs.writeFileSync(path.resolve(folder, 'index.ts'), [
         `export * from './${entityName}.store.ts'`,
-        `export * from './${entityName}.store.prisma.ts'`,
+        prismaPath ? `export * from './${entityName}.store.prisma.ts'` : undefined,
         `export * from './${entityName}.store.ram.ts'`
-    ].join('\n'))
+    ].filter(x => typeof x === 'string').join('\n'))
 
     // update DI
     
@@ -446,13 +509,13 @@ function generateStores(lowerCase, upperCase, withEntityPreset) {
     insertBeforeLineInFile(
         diEntriesPath,
         'type DIEntries =',
-        `import { ${upperCase}PrismaStore, ${upperCase}RAMStore } from '${config?.paths?.stores.replace('./src', '@')}/${entityName}'\n`
+        prismaPath ? `import { ${upperCase}PrismaStore, ${upperCase}RAMStore } from '${config?.paths?.stores.replace('./src', '@')}/${entityName}'\n` : `import { ${upperCase}RAMStore } from '${config?.paths?.stores.replace('./src', '@')}/${entityName}'\n`
     )
 
     insertAfterLineInFile(
         diEntriesPath,
         '// Stores',
-        `\t${upperCase}Store: { test: [${upperCase}RAMStore, (x) => x.inSingletonScope()], prod: ${upperCase}PrismaStore, dev: ${upperCase}PrismaStore },`,
+        prismaPath ? `\t${upperCase}Store: { test: [${upperCase}RAMStore, (x) => x.inSingletonScope()], prod: ${upperCase}PrismaStore, dev: ${upperCase}PrismaStore },` : `\t${upperCase}Store: ${upperCase}RAMStore,`,
     )
 
 }
@@ -471,13 +534,13 @@ function generateEntity(upperCase) {
 
     const body = [
         "import z from 'zod'",
-        "import { Entities } from '@alevnyacow/nzmt'",
+        "import { ValueObjects } 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\tid: ValueObjects.Identifier.schema,",
         fields.length ? 
             fields.map(([fieldName, description]) => {
                 return `\t\t${fieldName}: z.${description.split('.').join('().')}(),`
@@ -628,7 +691,7 @@ function generateService(lowerCase, upperCase, withCrud) {
     // Metadata
     if (withCrud) {
         fs.writeFileSync(path.resolve(folder, `${entityName}.service.metadata.ts`), [
-            "import { type Module, Entities } from '@alevnyacow/nzmt'",
+            "import { type Module, ValueObjects } from '@alevnyacow/nzmt'",
             "import z from 'zod'",
             `import { ${lowerCase}StoreMetadata } from '${config?.paths?.stores?.replace('./src', '@')}/${entityName}'`,
             "",
@@ -646,7 +709,7 @@ function generateService(lowerCase, upperCase, withCrud) {
             `\t\tgetList: {`,
             `\t\t\tpayload: z.object({`,
             `\t\t\t\tfilter: ${lowerCase}StoreMetadata.searchPayload.list,`,
-            `\t\t\t\tpagination: Entities.Pagination.schema.optional()`,
+            `\t\t\t\tpagination: ValueObjects.Pagination.schema.optional()`,
             `\t\t\t}),`,
             `\t\t\tresponse: z.object({`,
             `\t\t\t\titems: z.array(${lowerCase}StoreMetadata.models.list)`,
@@ -664,7 +727,7 @@ function generateService(lowerCase, upperCase, withCrud) {
             `\t\t\t\tpayload: ${lowerCase}StoreMetadata.actionsPayload.create`,
             `\t\t\t}),`,
             `\t\t\tresponse: z.object({`,
-            `\t\t\t\tid: Entities.Identifier.schema`,
+            `\t\t\t\tid: ValueObjects.Identifier.schema`,
             `\t\t\t}),`,
             `\t\t},`,
             `\t\tdeleteOne: {`,

package/dist/index.cjs

@@ -36,7 +36,7 @@ __webpack_require__.d(__webpack_exports__, {
     Controller: ()=>zod_controller_utils_namespaceObject,
     Store: ()=>store_namespaceObject,
     Module: ()=>zod_module_utils_namespaceObject,
-    Entities: ()=>entities_namespaceObject
+    ValueObjects: ()=>entities_namespaceObject
 });
 var zod_module_utils_namespaceObject = {};
 __webpack_require__.r(zod_module_utils_namespaceObject);
@@ -540,14 +540,14 @@ class Identifier {
     }
 }
 exports.Controller = __webpack_exports__.Controller;
-exports.Entities = __webpack_exports__.Entities;
 exports.Module = __webpack_exports__.Module;
 exports.Store = __webpack_exports__.Store;
+exports.ValueObjects = __webpack_exports__.ValueObjects;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "Controller",
-    "Entities",
     "Module",
-    "Store"
+    "Store",
+    "ValueObjects"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.d.ts

@@ -1,4 +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';
+export * as ValueObjects from './entities';

package/dist/index.js

@@ -499,4 +499,4 @@ class Identifier {
         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 };
+export { entities_namespaceObject as ValueObjects, store_namespaceObject as Store, zod_controller_utils_namespaceObject as Controller, zod_module_utils_namespaceObject as Module };

package/package.json

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