@domain-first/project-structure 2.1.0 → 2.3.0

package/dist/config-file.d.ts

@@ -10,6 +10,7 @@ declare const configSchema: z.ZodObject<{
     }>>;
     defaultPersistenceLayerImplementation: z.ZodString;
     useReact: z.ZodBoolean;
+    testingLibrary: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare class ConfigFile {
     readonly data: z.infer<typeof configSchema>;

package/dist/index.cjs

@@ -125,7 +125,8 @@ const configSchema = external_zod_default().object({
         '@domain-first/handlers-rest'
     ])),
     defaultPersistenceLayerImplementation: external_zod_default().string(),
-    useReact: external_zod_default().boolean()
+    useReact: external_zod_default().boolean(),
+    testingLibrary: external_zod_default().string().optional()
 });
 class ConfigFile {
     data;
@@ -170,11 +171,20 @@ const initializeUseCase = async ()=>{
     const useReact = await (0, prompts_namespaceObject.confirm)({
         message: 'Use React'
     });
+    let testingLibrary;
+    const withTests = await (0, prompts_namespaceObject.confirm)({
+        message: 'Scaffold unit tests'
+    });
+    if (withTests) testingLibrary = await (0, prompts_namespaceObject.input)({
+        message: 'Unit testing library:',
+        default: 'vitest'
+    });
     ConfigFile.write({
         rootFolder: rootFolderName,
         domainFirstPackages,
         defaultPersistenceLayerImplementation,
-        useReact
+        useReact,
+        testingLibrary
     });
     const { path } = new ProjectRoot();
     const rootFolder = new Folder(path);
@@ -225,12 +235,19 @@ class UnknownFormatNaming {
     get ClassName() {
         return this.PascalCase;
     }
+    get withSpaces() {
+        return this.fileName.replaceAll('-', ' ');
+    }
 }
 const scaffoldNewAggregateUseCase = async (boundedContextFolder)=>{
     const aggregateName = await (0, prompts_namespaceObject.input)({
         message: 'Aggregate name:'
     });
     const aggregateNaming = new UnknownFormatNaming(aggregateName);
+    let scaffoldUnitTests;
+    if (ConfigFile.Instance.data.testingLibrary) scaffoldUnitTests = await (0, prompts_namespaceObject.confirm)({
+        message: 'Scaffold unit-tests'
+    });
     const withRepository = await (0, prompts_namespaceObject.confirm)({
         message: 'With Repository'
     });
@@ -246,9 +263,42 @@ export class ${aggregateNaming.ClassName} extends domainType() {
 
 }`.trim() : `export class ${aggregateNaming.ClassName} {}`);
     const barrelFile = aggregatesFolder.createFile("index.ts", `export * from './${aggregateNaming.fileName}.aggregate-root'`);
+    if (scaffoldUnitTests) aggregatesFolder.createFile(`${aggregateNaming.fileName}.aggregate-root.spec.ts`, `
+import { describe, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { ${aggregateNaming.ClassName} } from './${aggregateNaming.fileName}.aggregate-root'
+
+let ${aggregateNaming.variableName}: ${aggregateNaming.ClassName}
+
+beforeEach(() => {
+    ${aggregateNaming.variableName} = new ${aggregateNaming.ClassName}()
+})
+
+describe('${aggregateNaming.withSpaces}', () => {
+    test('can be instantiated via constructor', () => {
+        expect(${aggregateNaming.variableName}).toBeDefined()
+    })
+})
+            `);
     if (withRepository) {
         aggregatesFolder.createFile(`${aggregateNaming.fileName}-repository.ts`, `export abstract class ${aggregateNaming.ClassName}Repository { }`);
         barrelFile.addLine(`export * from './${aggregateNaming.fileName}-repository'`);
+        if (scaffoldUnitTests) aggregatesFolder.createFile(`${aggregateNaming.fileName}-repository.spec.ts`, `
+import { describe, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { wire${aggregateNaming.ClassName}Repository } from '../../../wiring/repositories/wire-${aggregateNaming.fileName}-repository'
+import type { ${aggregateNaming.ClassName}Repository } from './${aggregateNaming.fileName}-repository'
+
+let ${aggregateNaming.variableName}Repository: ${aggregateNaming.ClassName}Repository
+
+beforeEach(() => {
+    ${aggregateNaming.variableName}Repository = wire${aggregateNaming.ClassName}Repository()
+})
+
+describe('${aggregateNaming.withSpaces} repository', () => {
+    test('can be wired', () => {
+        expect(${aggregateNaming.variableName}Repository).toBeDefined()
+    })
+})
+                `.trim());
         const infrastructureImplementationType = await (0, prompts_namespaceObject.input)({
             message: 'Repository infrastructure implementation type:',
             default: 'prisma'
@@ -310,6 +360,10 @@ const scaffoldNewApplicationPort = async (boundedContextFolder)=>{
         message: 'Name: '
     });
     const naming = new UnknownFormatNaming(name);
+    let scaffoldUnitTests;
+    if (ConfigFile.Instance.data.testingLibrary) scaffoldUnitTests = await (0, prompts_namespaceObject.confirm)({
+        message: 'Scaffold unit-tests'
+    });
     const wiringFolder = boundedContextFolder.subitem([
         'wiring',
         'ports'
@@ -323,8 +377,26 @@ export abstract class ${naming.ClassName} {
 
 }
             `.trim());
+    if (scaffoldUnitTests) applicationPortsFolder.createFile(`${naming.fileName}.spec.ts`, `
+import { define, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { type ${naming.ClassName} } from './${naming.fileName}'
+import { wire${naming.ClassName} } from '../../wiring/ports/wire-${naming.fileName}'
+
+let ${naming.variableName}: ${naming.ClassName}
+
+beforeEach(() => {
+    ${naming.variableName} = wire${naming.ClassName}()
+})
+
+define('${naming.withSpaces}', () => {
+    test('can be wired', () => {
+        expect(${naming.variableName}).toBeDefined()
+    })
+})
+    `.trim());
     const implementationType = await (0, prompts_namespaceObject.input)({
-        message: 'Adapter implementation type:'
+        message: 'Adapter implementation type:',
+        default: 'api'
     });
     const addTestImplementation = await (0, prompts_namespaceObject.confirm)({
         message: 'With test implementation'

package/dist/index.js

@@ -95,7 +95,8 @@ const configSchema = zod.object({
         '@domain-first/handlers-rest'
     ])),
     defaultPersistenceLayerImplementation: zod.string(),
-    useReact: zod.boolean()
+    useReact: zod.boolean(),
+    testingLibrary: zod.string().optional()
 });
 class ConfigFile {
     data;
@@ -140,11 +141,20 @@ const initializeUseCase = async ()=>{
     const useReact = await prompts_confirm({
         message: 'Use React'
     });
+    let testingLibrary;
+    const withTests = await prompts_confirm({
+        message: 'Scaffold unit tests'
+    });
+    if (withTests) testingLibrary = await input({
+        message: 'Unit testing library:',
+        default: 'vitest'
+    });
     ConfigFile.write({
         rootFolder: rootFolderName,
         domainFirstPackages,
         defaultPersistenceLayerImplementation,
-        useReact
+        useReact,
+        testingLibrary
     });
     const { path } = new ProjectRoot();
     const rootFolder = new Folder(path);
@@ -195,12 +205,19 @@ class UnknownFormatNaming {
     get ClassName() {
         return this.PascalCase;
     }
+    get withSpaces() {
+        return this.fileName.replaceAll('-', ' ');
+    }
 }
 const scaffoldNewAggregateUseCase = async (boundedContextFolder)=>{
     const aggregateName = await input({
         message: 'Aggregate name:'
     });
     const aggregateNaming = new UnknownFormatNaming(aggregateName);
+    let scaffoldUnitTests;
+    if (ConfigFile.Instance.data.testingLibrary) scaffoldUnitTests = await prompts_confirm({
+        message: 'Scaffold unit-tests'
+    });
     const withRepository = await prompts_confirm({
         message: 'With Repository'
     });
@@ -216,9 +233,42 @@ export class ${aggregateNaming.ClassName} extends domainType() {
 
 }`.trim() : `export class ${aggregateNaming.ClassName} {}`);
     const barrelFile = aggregatesFolder.createFile("index.ts", `export * from './${aggregateNaming.fileName}.aggregate-root'`);
+    if (scaffoldUnitTests) aggregatesFolder.createFile(`${aggregateNaming.fileName}.aggregate-root.spec.ts`, `
+import { describe, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { ${aggregateNaming.ClassName} } from './${aggregateNaming.fileName}.aggregate-root'
+
+let ${aggregateNaming.variableName}: ${aggregateNaming.ClassName}
+
+beforeEach(() => {
+    ${aggregateNaming.variableName} = new ${aggregateNaming.ClassName}()
+})
+
+describe('${aggregateNaming.withSpaces}', () => {
+    test('can be instantiated via constructor', () => {
+        expect(${aggregateNaming.variableName}).toBeDefined()
+    })
+})
+            `);
     if (withRepository) {
         aggregatesFolder.createFile(`${aggregateNaming.fileName}-repository.ts`, `export abstract class ${aggregateNaming.ClassName}Repository { }`);
         barrelFile.addLine(`export * from './${aggregateNaming.fileName}-repository'`);
+        if (scaffoldUnitTests) aggregatesFolder.createFile(`${aggregateNaming.fileName}-repository.spec.ts`, `
+import { describe, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { wire${aggregateNaming.ClassName}Repository } from '../../../wiring/repositories/wire-${aggregateNaming.fileName}-repository'
+import type { ${aggregateNaming.ClassName}Repository } from './${aggregateNaming.fileName}-repository'
+
+let ${aggregateNaming.variableName}Repository: ${aggregateNaming.ClassName}Repository
+
+beforeEach(() => {
+    ${aggregateNaming.variableName}Repository = wire${aggregateNaming.ClassName}Repository()
+})
+
+describe('${aggregateNaming.withSpaces} repository', () => {
+    test('can be wired', () => {
+        expect(${aggregateNaming.variableName}Repository).toBeDefined()
+    })
+})
+                `.trim());
         const infrastructureImplementationType = await input({
             message: 'Repository infrastructure implementation type:',
             default: 'prisma'
@@ -280,6 +330,10 @@ const scaffoldNewApplicationPort = async (boundedContextFolder)=>{
         message: 'Name: '
     });
     const naming = new UnknownFormatNaming(name);
+    let scaffoldUnitTests;
+    if (ConfigFile.Instance.data.testingLibrary) scaffoldUnitTests = await prompts_confirm({
+        message: 'Scaffold unit-tests'
+    });
     const wiringFolder = boundedContextFolder.subitem([
         'wiring',
         'ports'
@@ -293,8 +347,26 @@ export abstract class ${naming.ClassName} {
 
 }
             `.trim());
+    if (scaffoldUnitTests) applicationPortsFolder.createFile(`${naming.fileName}.spec.ts`, `
+import { define, test, expect, beforeEach } from '${ConfigFile.Instance.data.testingLibrary}'
+import { type ${naming.ClassName} } from './${naming.fileName}'
+import { wire${naming.ClassName} } from '../../wiring/ports/wire-${naming.fileName}'
+
+let ${naming.variableName}: ${naming.ClassName}
+
+beforeEach(() => {
+    ${naming.variableName} = wire${naming.ClassName}()
+})
+
+define('${naming.withSpaces}', () => {
+    test('can be wired', () => {
+        expect(${naming.variableName}).toBeDefined()
+    })
+})
+    `.trim());
     const implementationType = await input({
-        message: 'Adapter implementation type:'
+        message: 'Adapter implementation type:',
+        default: 'api'
     });
     const addTestImplementation = await prompts_confirm({
         message: 'With test implementation'

package/dist/unknown-format-naming.d.ts

@@ -6,4 +6,5 @@ export declare class UnknownFormatNaming {
     get fileName(): string;
     get variableName(): string;
     get ClassName(): string;
+    get withSpaces(): string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@domain-first/project-structure",
     "description": "Build and manage your Domain-First project structure with CLI",
-    "version": "2.1.0",
+    "version": "2.3.0",
     "type": "module",
     "repository": {
         "type": "git",