tshex-cli 1.0.16 → 1.0.18

package/build/main.js

@@ -31,35 +31,9 @@ function executeCreateContext(templatesDir, contextDir) {
         console.error(err);
     }
 }
-function copyDirectoryContents(sourceDir, destinationDir) {
-    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const destinationPath = path.join(destinationDir, entry.name);
-        if (fs.existsSync(destinationPath) === false) {
-            fs.cpSync(sourcePath, destinationPath, {
-                recursive: true,
-                filter: (src) => src.endsWith('.gitkeep') === false
-            });
-        }
-    }
-}
-function executeCreateReactProject(templatesDir, projectDir) {
-    try {
-        fs.cpSync(path.join(templatesDir, 'react-project'), projectDir, {
-            recursive: true,
-            filter: (src) => src.endsWith('.gitkeep') === false
-        });
-        copyDirectoryContents(path.join(templatesDir, 'lib', 'shared'), path.join(projectDir, 'core', 'shared'));
-        console.log('React project created successfully');
-    }
-    catch (err) {
-        console.error(err);
-    }
-}
 function executeCreateReactContext(templatesDir, contextDir) {
     try {
-        fs.cpSync(path.join(templatesDir, 'react-context'), contextDir, {
+        fs.cpSync(path.join(templatesDir, 'ctx-react'), contextDir, {
             recursive: true,
             filter: (src) => src.endsWith('.gitkeep') === false
         });
@@ -83,17 +57,17 @@ function main(program) {
         targetDir = path.join(targetDir, options.lib);
         executeCreateLib(templatesDir, targetDir);
     }
+    if (options.react === true && options.ctx === undefined) {
+        program.error('Option --react requires --ctx <name>');
+    }
     if (options.ctx !== undefined) {
         targetDir = path.join(targetDir, options.ctx);
-        executeCreateContext(templatesDir, targetDir);
-    }
-    if (options.reactProject !== undefined) {
-        targetDir = path.join(targetDir, options.reactProject);
-        executeCreateReactProject(templatesDir, targetDir);
-    }
-    if (options.reactContext !== undefined) {
-        targetDir = path.join(targetDir, options.reactContext);
-        executeCreateReactContext(templatesDir, targetDir);
+        if (options.react === true) {
+            executeCreateReactContext(templatesDir, targetDir);
+        }
+        else {
+            executeCreateContext(templatesDir, targetDir);
+        }
     }
 }
 const packageJson = readPackageJson();
@@ -102,8 +76,7 @@ program
     .version(packageJson.version)
     .option('--lib <name>', "creates a new library with it's shared directory")
     .option('--ctx <name>', 'creates a new context')
+    .option('-R, --react', 'creates a React context with --ctx')
     .option('--dir <path>', 'sets the directory to create the new item')
-    .option('--react-project <name>', 'creates a new React project')
-    .option('--react-context <name>', 'creates a new React context')
     .parse(process.argv);
 main(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tshex-cli",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "author": "https://github.com/virtualitems/",
   "description": "Typescript Hexagonal Architecture CLI",
   "type": "module",
@@ -26,25 +26,23 @@
   "bugs": {
     "url": "https://github.com/virtualitems/tshex-cli/issues"
   },
+  "types": "./source/index.d.ts",
   "files": [
     "./build",
     "./source",
     "./templates"
   ],
-  "types": "./source/index.d.ts",
-  "devDependencies": {
-    "@types/node": "^22.5.4",
-    "typescript": "^5.4.5"
+  "bin": {
+    "tshex": "./build/main.js"
   },
   "dependencies": {
     "commander": "^12.1.0"
   },
-  "bin": {
-    "tshex": "./build/main.js"
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "typescript": "^5.4.5"
   },
   "scripts": {
-    "examples": "tsc -p examples",
-    "build": "tsc",
-    "dev": "tsc -w"
+    "build": "tsc"
   }
 }

package/source/main.ts

@@ -41,40 +41,9 @@ function executeCreateContext(templatesDir: string, contextDir: string) {
     }
 }
 
-function copyDirectoryContents(sourceDir: string, destinationDir: string) {
-    const entries = fs.readdirSync(sourceDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name)
-        const destinationPath = path.join(destinationDir, entry.name)
-
-        if (fs.existsSync(destinationPath) === false) {
-            fs.cpSync(sourcePath, destinationPath, {
-                recursive: true,
-                filter: (src) => src.endsWith('.gitkeep') === false
-            })
-        }
-    }
-}
-
-function executeCreateReactProject(templatesDir: string, projectDir: string) {
-    try {
-        fs.cpSync(path.join(templatesDir, 'react-project'), projectDir, {
-            recursive: true,
-            filter: (src) => src.endsWith('.gitkeep') === false
-        })
-
-        copyDirectoryContents(path.join(templatesDir, 'lib', 'shared'), path.join(projectDir, 'core', 'shared'))
-
-        console.log('React project created successfully')
-    } catch (err) {
-        console.error(err)
-    }
-}
-
 function executeCreateReactContext(templatesDir: string, contextDir: string) {
     try {
-        fs.cpSync(path.join(templatesDir, 'react-context'), contextDir, {
+        fs.cpSync(path.join(templatesDir, 'ctx-react'), contextDir, {
             recursive: true,
             filter: (src) => src.endsWith('.gitkeep') === false
         })
@@ -104,19 +73,18 @@ function main(program: typeof import('commander').program) {
         executeCreateLib(templatesDir, targetDir)
     }
 
-    if (options.ctx !== undefined) {
-        targetDir = path.join(targetDir, options.ctx)
-        executeCreateContext(templatesDir, targetDir)
+    if (options.react === true && options.ctx === undefined) {
+        program.error('Option --react requires --ctx <name>')
     }
 
-    if (options.reactProject !== undefined) {
-        targetDir = path.join(targetDir, options.reactProject)
-        executeCreateReactProject(templatesDir, targetDir)
-    }
+    if (options.ctx !== undefined) {
+        targetDir = path.join(targetDir, options.ctx)
 
-    if (options.reactContext !== undefined) {
-        targetDir = path.join(targetDir, options.reactContext)
-        executeCreateReactContext(templatesDir, targetDir)
+        if (options.react === true) {
+            executeCreateReactContext(templatesDir, targetDir)
+        } else {
+            executeCreateContext(templatesDir, targetDir)
+        }
     }
 }
 
@@ -127,9 +95,8 @@ program
     .version(packageJson.version)
     .option('--lib <name>', "creates a new library with it's shared directory")
     .option('--ctx <name>', 'creates a new context')
+    .option('-R, --react', 'creates a React context with --ctx')
     .option('--dir <path>', 'sets the directory to create the new item')
-    .option('--react-project <name>', 'creates a new React project')
-    .option('--react-context <name>', 'creates a new React context')
     .parse(process.argv)
 
 main(program)

package/templates/ctx/example-ports.ts

@@ -0,0 +1,5 @@
+// Ports are exports from the context root level
+
+export function example(): void {
+    // ...
+}

package/templates/lib/shared/application/data-sources.ts

@@ -0,0 +1,102 @@
+type Generic<T = unknown> = Record<string, T>
+
+/**
+ * @description
+ */
+export interface Filterable<S = Generic> {
+    filter(selector: S): Promise<Array<S>>
+}
+
+/**
+ * @description
+ */
+export interface Sortable<S = Generic> {
+    sort(selector: S): Promise<Array<S>>
+}
+
+/**
+ * @description
+ */
+export interface Creatable<D = Generic> {
+    create(data: D): Promise<unknown>
+}
+
+/**
+ * @description
+ */
+export interface Updatable<S = Generic, D = Generic> {
+    update(selector: S, data: D): Promise<unknown>
+}
+
+/**
+ * @description
+ */
+export interface Deletable<S = Generic> {
+    delete(selector: S): Promise<unknown>
+}
+
+/**
+ * @description
+ */
+export interface Aggregatable<S = Generic> {
+    aggregate(selector: S): Promise<S>
+}
+
+/**
+ * @description
+ */
+export interface Relatable {
+    selectRelated(...args: unknown[]): unknown
+
+    prefetchRelated(...args: unknown[]): unknown
+}
+
+/**
+ * @description
+ */
+export abstract class DataManager<T = Generic> {
+    [property: string]: unknown
+
+    public abstract all(): Promise<Array<T>>
+
+    public abstract none(): Array<T>
+} //:: class
+
+/**
+ * @description
+ */
+export abstract class DatasetManager<T = Generic> extends DataManager<T> {
+    [property: string]: unknown
+
+    public abstract union(other: Array<T>): Promise<Array<T>>
+
+    public abstract intersection(other: Array<T>): Promise<Array<T>>
+
+    public abstract difference(other: Array<T>): Promise<Array<T>>
+
+    public abstract symmetricDifference(other: Array<T>): Promise<Array<T>>
+
+    public abstract complement(other: Array<T>): Promise<Array<T>>
+} //:: class
+
+/**
+ * @description
+ */
+export abstract class DriverManager<M extends DataManager = DataManager> {
+    [property: string]: unknown
+
+    public abstract connect(...args: unknown[]): Promise<M>
+
+    public abstract disconnect(): Promise<unknown>
+} //:: class
+
+/**
+ * @description Represents a data source.
+ */
+export abstract class Repository<M extends DriverManager = DriverManager> {
+    [property: string]: unknown
+
+    public constructor(public readonly manager: M) {}
+
+    protected abstract transform<T = Generic>(data: Generic): T
+} //:: class

package/templates/lib/shared/application/http.ts

@@ -1,48 +1,36 @@
-// Libraries
-
-// Same Layer
-
-// Lower Layers
-
-// Types
+/**
+ * @description
+ */
+export interface HttpRequest {}
 
-// Constants
+/**
+ * @description
+ */
+export interface HttpResponse {}
 
 /**
  * @description
  */
-export class HttpResponseBody {
+export interface HttpResponseBody {
     [property: string]: unknown
+    readonly data: Record<string, unknown> | null
+    readonly errors: string[] | null
+    readonly links: Record<string, URL> | null
+}
 
-    // public ATTRIBUTES
-
-    // protected ATTRIBUTES
-
-    // private ATTRIBUTES
-
-    // public static ATTRIBUTES
-
-    // protected static ATTRIBUTES
-
-    // private static ATTRIBUTES
-
-    // Constructor, Getters, Setters
-
-    public constructor(
-        public readonly data: Record<string, unknown> | null = null,
-        public readonly errors: string[] | null = null,
-        public readonly links: Record<string, URL> | null = null
-    ) {}
-
-    // public METHODS
-
-    // protected METHODS
-
-    // private METHODS
-
-    // public static METHODS
-
-    // protected static METHODS
+/**
+ * @description
+ */
+export interface HttpRequestHandler {
+    handle(request: HttpRequest): HttpResponse | Promise<HttpResponse>
+}
 
-    // private static METHODS
-} //:: class
+/**
+ * @description
+ */
+export interface HttpMiddleware {
+    process(
+        request: HttpRequest,
+        handler: HttpRequestHandler
+    ): HttpResponse | Promise<HttpResponse>
+}

package/templates/lib/shared/application/loggers.ts

@@ -1,12 +1,12 @@
-// Libraries
+export const DEBUG = 10
 
-// Same Layer
+export const INFO = 20
 
-// Lower Layers
+export const WARNING = 30
 
-// Types
+export const ERROR = 40
 
-// Constants
+export const CRITICAL = 50
 
 /**
  * @description
@@ -14,22 +14,6 @@
 export abstract class Logger {
     [property: string]: unknown
 
-    // public ATTRIBUTES
-
-    // protected ATTRIBUTES
-
-    // private ATTRIBUTES
-
-    // public static ATTRIBUTES
-
-    // protected static ATTRIBUTES
-
-    // private static ATTRIBUTES
-
-    // Constructor, Getters, Setters
-
-    // public METHODS
-
     public abstract debug(data: unknown): void
 
     public abstract info(data: unknown): void
@@ -38,13 +22,5 @@ export abstract class Logger {
 
     public abstract error(data: unknown): void
 
-    // protected METHODS
-
-    // private METHODS
-
-    // public static METHODS
-
-    // protected static METHODS
-
-    // private static METHODS
+    public abstract critical(data: unknown): void
 } //:: class

package/templates/lib/shared/application/validations.ts

@@ -0,0 +1,10 @@
+/**
+ * @description
+ */
+export interface Validatable {
+    [property: string]: unknown
+
+    isValid(): boolean
+
+    validate(): unknown
+}

package/readme.md

@@ -1,229 +0,0 @@
-# Hexagonal Architecture CLI
-
-This CLI will help you to generate a hexagonal architecture structure.
-
-# Why?
-
-Hexagonal architecture is a software design pattern that separates the internal domain of the application from the external dependencies. This separation is achieved by dividing the application into layers. Each layer has a specific responsibility and interacts with the other layers in a specific way.
-
-The goal is to separate the domain code from installed dependencies. A Hexagonal Architecture _framework_ would work against that goal, since it couples the domain code to the framework itself. That is why this CLI exists: it scaffolds the structure for you, using your own codebase instead of a framework.
-
-# Note
-
-This tool and its templates are in constant development, so be aware that some changes may occur and be careful when updating the tool.
-
-If you have any suggestions or improvements, please let me know.
-
-https://github.com/virtualitems/tshex-cli/issues
-
-# Getting started
-
-`tshex` scaffolds folders and files for a hexagonal architecture project. It does not write business logic for you; it only generates the structure, so you can fill it in with your own code.
-
-There are four things you can generate:
-
-- A **library** (`--lib`): the shared foundation of a project. It contains the domain and application contracts (entities, value objects, services, etc.) that the rest of the code depends on.
-- A **context** (`--ctx`): a specific business area (e.g. `users`, `billing`, `orders`). It contains the `domain/`, `application/`, and `adapters/` folders where you implement that area's logic.
-- A **React project** (`--react-project`): a full React-oriented hexagonal structure with `core/`, `dom-client/`, `dom-server/`, and `native/` folders.
-- A **React context** (`--react-context`): a React-ready context scaffold.
-
-A typical project has one library and one or more contexts inside it.
-
-## Install
-
-Install the CLI globally:
-
-```bash
-npm install -g tshex-cli
-```
-
-Check the installation:
-
-```bash
-tshex --version
-```
-
-Show the command options:
-
-```bash
-tshex --help
-```
-
-## Usage
-
-```bash
-tshex [--lib <name>] [--ctx <name>] [--react-project <name>] [--react-context <name>] [--dir <path>]
-```
-
-| Option         | Purpose                                                            |
-| -------------- | ------------------------------------------------------------------- |
-| `--lib <name>` | Generate a library called `<name>`, based on `templates/lib`.       |
-| `--ctx <name>` | Generate a context called `<name>`, based on `templates/ctx`.       |
-| `--react-project <name>` | Generate a React project called `<name>`, based on `templates/react-project` and `templates/lib/shared`. |
-| `--react-context <name>` | Generate a React context called `<name>`, based on `templates/react-context`. |
-| `--dir <path>` | Parent directory where the library/context will be created. Defaults to the current directory. |
-| `--help`       | Show the command options.                                           |
-| `--version`    | Show the installed version.                                         |
-
-`--lib`, `--ctx`, `--react-project`, and `--react-context` can be used together in a single command. Running `tshex` without any options just prints the help text — it does not generate anything.
-
-## Create a library
-
-Use this when you are starting a new project and need the shared contracts that the rest of your code will build on:
-
-```bash
-tshex --lib core
-```
-
-This generates a `core/` folder in the current directory:
-
-```text
-core/
-├── index.d.ts
-├── main.ts
-└── shared/
-    ├── application/
-    │   ├── databases.ts
-    │   ├── events.ts
-    │   ├── http.ts
-    │   ├── loggers.ts
-    │   └── services.ts
-    └── domain/
-        ├── aggregates.ts
-        ├── entities.ts
-        ├── errors.ts
-        └── value-objects.ts
-```
-
-What each file is for:
-
-| File               | Purpose                                       |
-| ------------------ | --------------------------------------------- |
-| `index.d.ts`       | Declare library types.                        |
-| `main.ts`          | Export the library API.                       |
-| `entities.ts`      | Define entity contracts.                      |
-| `value-objects.ts` | Define value objects and validation.          |
-| `aggregates.ts`    | Define aggregate contracts.                   |
-| `errors.ts`        | Define domain errors.                         |
-| `services.ts`      | Define application service contracts.         |
-| `databases.ts`     | Define data manager and repository contracts. |
-| `events.ts`        | Define event contracts.                       |
-| `http.ts`          | Define HTTP response contracts.               |
-| `loggers.ts`       | Define logger contracts.                      |
-
-`main.ts` is generated with a placeholder `throw new Error('Not implemented yet')`, so the library fails loudly if you try to use it before filling it in. To start using it, open `main.ts`, remove that line, and export your own code, built on top of the shared contracts. For example:
-
-```ts
-export { Entity } from './shared/domain/entities.js'
-export { ValueObject, Email } from './shared/domain/value-objects.js'
-
-class User extends Entity {
-    constructor(public readonly email: Email) {
-        super()
-    }
-}
-```
-
-## Create a context
-
-Use this to scaffold a specific business area, such as `users`, inside an existing library (or on its own):
-
-```bash
-tshex --ctx users
-```
-
-This generates a `users/` folder in the current directory:
-
-```text
-users/
-├── adapters/
-├── application/
-├── domain/
-└── index.ts
-```
-
-What each part is for:
-
-| Path           | Purpose                                                         |
-| -------------- | ---------------------------------------------------------------- |
-| `domain/`      | Entities, value objects, aggregates, and domain errors.          |
-| `application/` | Use cases, services, DTOs, and contracts.                        |
-| `adapters/`    | Database, HTTP, event, file, and service implementations.        |
-| `index.ts`     | Export or compose the context's public API.                      |
-
-## Choose the destination folder
-
-By default, `tshex` creates files in your current directory. Use `--dir` to choose a different parent directory instead.
-
-Create a library inside `./src`:
-
-```bash
-tshex --lib core --dir ./src
-```
-
-This generates the library at:
-
-```text
-./src/core
-```
-
-Create a context inside that library:
-
-```bash
-tshex --ctx users --dir ./src/core
-```
-
-This generates the context at:
-
-```text
-./src/core/users
-```
-
-You can also use an absolute path:
-
-```bash
-tshex --ctx users --dir /workspace/project/src
-```
-
-## Create a library and a context together
-
-You can generate both in a single command. `tshex` creates the library first, then creates the context inside it:
-
-```bash
-tshex --dir ./src --lib core --ctx users
-```
-
-Result:
-
-```text
-src/
-└── core/
-    ├── index.d.ts
-    ├── main.ts
-    ├── shared/
-    └── users/
-        ├── adapters/
-        ├── application/
-        ├── domain/
-        └── index.ts
-```
-
-    ## Create a React project
-
-    Use this when you want the React-specific project scaffold with the shared `core/shared` contracts copied from the library template:
-
-    ```bash
-    tshex --react-project app
-    ```
-
-    This generates a `app/` folder in the current directory.
-
-    ## Create a React context
-
-    Use this when you want only the React context scaffold:
-
-    ```bash
-    tshex --react-context users
-    ```
-
-    This generates a `users/` folder in the current directory.