@apso/cli 0.1.9 → 0.3.0

package/README.md

@@ -5,6 +5,7 @@
 - [Usage](#usage)
 - [Local Development](#local-development)
 - [Populating an .apsorc File](#populating-an-apsorc-file)
+- [Auto-Generated Code Reference](#auto-generated-code-reference)
 - [Debugging](##debugging)
 - [Commands](#commands)
 
@@ -57,6 +58,94 @@ Follow these steps to create and run a new APSO server project:
 
 > For more details on configuring your schema, see the [Populating an .apsorc File](#populating-an-apsorc-file) section below.
 
+---
+
+## 📢 Important: Never Add Custom Code to Autogen Files
+
+Apso CLI generates all files in the `autogen/` directory automatically.  
+**Any changes you make directly to these files will be overwritten the next time you run Apso CLI.**  
+To keep your custom logic safe and maintainable, always use the `extensions/` directory for any customizations.
+
+### How to Extend Apso-Generated Entities
+
+#### 1. **Never modify files in `autogen/`**
+
+- All files in `src/autogen/` are managed by Apso CLI.
+- These include entities, services, controllers, DTOs, and modules.
+- **Do not add custom endpoints, business logic, or integrations here.**
+
+#### 2. **Add custom logic in `extensions/`**
+
+- For each entity you want to extend, create a corresponding folder in `src/extensions/[[EntityName]]/`.
+- Add your custom service, controller, and DTOs here.
+- You can inject and extend the autogen service in your extension service.
+
+#### 3. **Example Directory Structure**
+
+```
+src/
+  autogen/
+    LambdaDeployment/
+      LambdaDeployment.service.ts   # DO NOT MODIFY
+      LambdaDeployment.controller.ts
+      ...
+  extensions/
+    LambdaDeployment/
+      LambdaDeployment.service.ts   # Add custom logic here
+      LambdaDeployment.controller.ts
+      ...
+```
+
+#### 4. **Example: Extending LambdaDeployment**
+
+**Custom Service:**
+```typescript
+// src/extensions/LambdaDeployment/LambdaDeployment.service.ts
+import { Injectable } from '@nestjs/common';
+import { LambdaDeploymentService as AutogenLambdaDeploymentService } from '../../autogen/LambdaDeployment/LambdaDeployment.service';
+
+@Injectable()
+export class LambdaDeploymentService extends AutogenLambdaDeploymentService {
+  // Add your custom methods here
+  async deployWithLocalService(...) { ... }
+}
+```
+
+**Custom Controller:**
+```typescript
+// src/extensions/LambdaDeployment/LambdaDeployment.controller.ts
+import { Controller } from '@nestjs/common';
+import { LambdaDeploymentService } from './LambdaDeployment.service';
+
+@Controller('lambda-deployment')
+export class LambdaDeploymentController {
+  constructor(private readonly lambdaDeploymentService: LambdaDeploymentService) {}
+
+  // Add custom endpoints here
+}
+```
+
+#### 5. **Why This Matters**
+
+- Keeps your custom business logic safe from being overwritten.
+- Makes it easy to regenerate your API as your data model evolves.
+- Maintains a clean separation between generated code and your application logic.
+
+#### 6. **Best Practices**
+
+- Only use the autogen files for base CRUD and entity logic.
+- Place all custom endpoints, integrations, and business logic in the `extensions/` directory.
+- If you need to override or extend a method, subclass the autogen service in your extension service.
+
+---
+
+**Summary:**  
+> Always put your custom code in `src/extensions/[[EntityName]]/`.  
+> Never modify files in `src/autogen/`.  
+> This ensures your work is safe and your project remains maintainable as you evolve your data model with Apso CLI.
+
+---
+
 # Local Development
 
 Clone apso-cli on your machine. Navigate to the repo in your code editor and run the below commands
@@ -169,6 +258,428 @@ The `.apsorc` file defines your domain model, including entities and their relat
 
 For a full example, see [`apso-cli/test/apsorc-json/apsorc.v2.json`](./test/apsorc-json/apsorc.v2.json).
 
+## Auto-Generated Code Reference
+
+This section details the code that Apso CLI automatically generates from your `.apsorc` configuration, including fields, TypeORM mappings, validation, and naming conventions. Understanding these rules will help you predict and control your generated backend code.
+
+### 1. Auto-Generated Fields
+
+#### Primary Keys
+- Every entity automatically receives an `id` field, even if not defined in the `fields` array.
+- Decorated as `@PrimaryGeneratedColumn()` (auto-incrementing integer).
+- Type: `number`.
+
+  ```typescript
+  @PrimaryGeneratedColumn()
+  id: number;
+  ```
+
+#### Timestamps
+- If `"created_at": true` is set on the entity, generates:
+  ```typescript
+  @CreateDateColumn()
+  created_at: Date;
+  ```
+- If `"updated_at": true` is set on the entity, generates:
+  ```typescript
+  @UpdateDateColumn()
+  updated_at: Date;
+  ```
+- These are in addition to any fields you define.
+
+#### Foreign Key Fields
+- For each relationship, Apso generates the foreign key column and TypeORM decorators.
+- Example:
+  ```json
+  { "from": "Workspace", "to": "User", "type": "ManyToOne", "to_name": "owner" }
+  ```
+  Generates:
+  ```typescript
+  @ManyToOne(() => User)
+  @JoinColumn({ name: 'ownerId' })
+  owner: User;
+
+  @Column({ type: 'integer' })
+  ownerId: number;
+  ```
+
+### 2. Field Type Mapping Table
+
+> **⚠️ PostGIS Requirements:** The following spatial data types require the PostGIS extension to be installed in your PostgreSQL database:
+> ```sql
+> CREATE EXTENSION IF NOT EXISTS postgis;
+> ```
+> Ensure PostGIS is installed before using any of the spatial data types listed below.
+
+| Apso Field Type | TypeORM Column Decorator                | Auto-Applied Validation                | Notes                                 |
+|-----------------|-----------------------------------------|----------------------------------------|---------------------------------------|
+| `text`          | `@Column({ type: 'text' })`             | `@IsString()`, `@IsNotEmpty()`         | With `length`: `@MaxLength(n)`        |
+| `json`          | `@Column('jsonb')`                      | None                                   | Uses JSONB in PostgreSQL              |
+| `enum`          | `@Column({ type: 'enum', enum: [...] })`| None                                   | Values array becomes enum             |
+| `boolean`       | `@Column({ type: 'boolean' })`          | `@IsBoolean()`                         | Default values supported              |
+| `integer`       | `@Column({ type: 'integer' })`          | `@IsNumber()`                          |                                       |
+| `decimal`       | `@Column({ type: 'decimal', precision: n, scale: m })` | `@IsNumber()`                          | Precision/scale supported             |
+| `numeric`       | `@Column({ type: 'numeric', precision: n, scale: m })` | `@IsNumber()`                          | Precision/scale supported             |
+| `timestamp`     | `@Column({ type: 'timestamp' })`        | None                                   |                                       |
+| `point`         | `@Column({ type: 'point' })`            | None                                   | PostGIS point geometry ⚠️ Requires PostGIS |
+| `linestring`    | `@Column({ type: 'linestring' })`       | None                                   | PostGIS line string geometry ⚠️ Requires PostGIS |
+| `polygon`       | `@Column({ type: 'polygon' })`          | None                                   | PostGIS polygon geometry ⚠️ Requires PostGIS |
+| `multipoint`    | `@Column({ type: 'multipoint' })`       | None                                   | PostGIS multi-point geometry ⚠️ Requires PostGIS |
+| `multilinestring` | `@Column({ type: 'multilinestring' })`  | None                                   | PostGIS multi-line string geometry ⚠️ Requires PostGIS |
+| `multipolygon`  | `@Column({ type: 'multipolygon' })`     | None                                   | PostGIS multi-polygon geometry ⚠️ Requires PostGIS |
+| `geometry`      | `@Column({ type: 'geometry' })`         | None                                   | PostGIS generic geometry type ⚠️ Requires PostGIS |
+| `geography`     | `@Column({ type: 'geography' })`        | None                                   | PostGIS geography type ⚠️ Requires PostGIS |
+| `geometrycollection` | `@Column({ type: 'geometrycollection' })` | None                              | PostGIS geometry collection ⚠️ Requires PostGIS |
+
+#### Decimal/Numeric Field Examples
+
+**Basic decimal field:**
+```json
+{
+  "name": "price",
+  "type": "decimal",
+  "precision": 10,
+  "scale": 2,
+  "default": 0,
+  "nullable": false
+}
+```
+Generates:
+```typescript
+@Column({ "type": "decimal", precision: 10, scale: 2, default: 0 })
+price: number;
+```
+
+**Numeric field with custom precision:**
+```json
+{
+  "name": "bandwidth_gb",
+  "type": "numeric",
+  "precision": 10,
+  "scale": 3,
+  "default": 0,
+  "nullable": false
+}
+```
+Generates:
+```typescript
+@Column({ "type": "numeric", precision: 10, scale: 3, default: 0 })
+bandwidth_gb: number;
+```
+
+#### PostGIS Field Examples
+
+> **📋 PostGIS Setup Required:** Before using any PostGIS data types, ensure your PostgreSQL database has the PostGIS extension installed:
+> ```sql
+> -- Install PostGIS extension
+> CREATE EXTENSION IF NOT EXISTS postgis;
+> 
+> -- Verify installation
+> SELECT PostGIS_Version();
+> ```
+> 
+> **Deployment Note:** When deploying applications with PostGIS fields, ensure the PostGIS extension is available in your production database environment.
+
+**Point geometry field:**
+```json
+{
+  "name": "location",
+  "type": "point",
+  "nullable": true
+}
+```
+Generates:
+```typescript
+@Column({
+  "type": "point",
+  transformer: {
+    to: (point: {x: number, y: number} | null) => {
+      if (!point) return null;
+      return `(${point.x},${point.y})`;
+    },
+    from: (pgPoint: string | null) => {
+      if (!pgPoint) return null;
+      const [x, y] = pgPoint.substring(1, pgPoint.length - 1).split(',');
+      return { x: parseFloat(x), y: parseFloat(y) };
+    }
+  },
+  nullable: true
+})
+location: { x: number, y: number };
+```
+
+**Polygon geometry field:**
+```json
+{
+  "name": "boundary",
+  "type": "polygon",
+  "nullable": true
+}
+```
+Generates:
+```typescript
+@Column({
+  "type": "polygon",
+  transformer: {
+    to: (polygon: { coordinates: Array<Array<{x: number, y: number}>> } | null) => {
+      if (!polygon) return null;
+      const rings = polygon.coordinates.map(ring => {
+        const coords = ring.map(coord => `${coord.x} ${coord.y}`).join(',');
+        return `(${coords})`;
+      });
+      return `POLYGON(${rings.join(',')})`;
+    },
+    from: (pgPolygon: string | null) => {
+      if (!pgPolygon) return null;
+      const match = pgPolygon.match(/POLYGON\((.+)\)/);
+      if (!match) return null;
+      const rings = match[1].split('),(').map(ring => {
+        const cleanRing = ring.replace(/[()]/g, '');
+        const coords = cleanRing.split(',').map(coord => {
+          const [x, y] = coord.trim().split(' ');
+          return { x: parseFloat(x), y: parseFloat(y) };
+        });
+        return coords;
+      });
+      return { coordinates: rings };
+    }
+  },
+  nullable: true
+})
+boundary: { coordinates: Array<Array<{ x: number, y: number }>> };
+```
+
+**Generic geometry field:**
+```json
+{
+  "name": "shape",
+  "type": "geometry",
+  "nullable": true
+}
+```
+Generates:
+```typescript
+@Column({
+  "type": "geometry",
+  transformer: {
+    to: (geometry: any) => {
+      if (!geometry) return null;
+      return geometry;
+    },
+    from: (pgGeometry: any) => {
+      if (!pgGeometry) return null;
+      return pgGeometry;
+    }
+  },
+  nullable: true
+})
+shape: any;
+```
+
+### 3. Validation Rules Documentation
+
+Field properties in `.apsorc` map to validation decorators as follows:
+
+- `"unique": true` → `@Column({ unique: true })`
+- `"nullable": true` → `@Column({ nullable: true })` and `@IsOptional()`
+- `"is_email": true` → `@IsEmail()`
+- `"length": 255` → `@MaxLength(255)`
+- `"precision": 10` → `@Column({ precision: 10 })` (for decimal/numeric types)
+- `"scale": 2` → `@Column({ scale: 2 })` (for decimal/numeric types)
+- `"required": false` → `@IsOptional()` (for CREATE group)
+
+### 4. Relationship Generation Rules
+
+#### OneToMany Relationships
+
+```json
+{ "from": "User", "to": "Workspace", "type": "OneToMany", "to_name": "ownedWorkspaces" }
+```
+Generates:
+```typescript
+@OneToMany(() => Workspace, (workspace) => workspace.user)
+ownedWorkspaces: Workspace[];
+```
+
+#### ManyToOne Relationships
+
+```json
+{ "from": "Workspace", "to": "User", "type": "ManyToOne", "to_name": "owner" }
+```
+Generates:
+```typescript
+@ManyToOne(() => User, (user) => user.ownedWorkspaces)
+@JoinColumn({ name: 'userId' })
+owner: User;
+
+@Column({ type: 'integer' })
+userId: number;
+```
+
+#### Foreign Key Naming
+- Foreign key columns use camelCase + `Id` (e.g., `userId`).
+- Join column names match the foreign key column name.
+
+### 5. Entity Naming Conventions
+- Entity class names remain as defined in `.apsorc` (e.g., `User`).
+- Table names are lowercased (e.g., `user`).
+- Foreign key columns use camelCase + `Id` (e.g., `userId`).
+- Join column names match the foreign key column name.
+
+### 6. Version 2 Format Differences
+
+Version 2 of the `.apsorc` format introduces several enhancements:
+- Separate `relationships` and `entities` arrays.
+- `created_at`/`updated_at` as boolean flags at the entity level.
+- Enhanced field types: `json`, `enum`, `timestamp`, `decimal`, `numeric`.
+- `to_name` property in relationships for custom property names.
+- `precision` and `scale` properties for decimal/numeric fields.
+
+Refer to the [example v2 file](#example-apsorc-v2-file) for usage.
+
+## Relationships
+
+### 1. Relationships Best Practices
+
+> **Important:** Only define ONE side of a relationship in your `.apsorc` file. Apso CLI will auto-generate the inverse side for you. Defining both sides leads to duplicate properties, compilation errors, and entity conflicts.
+
+#### DO/DON'T Examples
+
+```json
+// ❌ WRONG - Creates Conflicts:
+{ "from": "User", "to": "Workspace", "type": "OneToMany" },
+{ "from": "Workspace", "to": "User", "type": "ManyToOne" }
+
+// ✅ CORRECT - One Side Only:
+{ "from": "Workspace", "to": "User", "type": "ManyToOne", "to_name": "owner" }
+```
+
+- **DO:** Define only the direction that best fits your domain model.
+- **DON'T:** Define both directions for the same relationship.
+- **Why?** Apso CLI auto-generates the inverse property and decorators. Duplicating both sides causes duplicate property and foreign key generation.
+
+### 2. Auto-Generated Properties Documentation
+
+#### ManyToOne Relationships
+- Generates:
+  - Entity property with `@ManyToOne`, `@JoinColumn`, and `@Column` decorators
+  - Foreign key column: `{relationName}Id`
+  - Example:
+    ```typescript
+    @ManyToOne(() => User)
+    @JoinColumn({ name: 'ownerId' })
+    owner: User;
+
+    @Column({ type: 'integer' })
+    ownerId: number;
+    ```
+
+#### OneToMany Relationships
+- Generates:
+  - Array property with `@OneToMany` decorator
+  - Inverse mapping to the ManyToOne property
+  - Example:
+    ```typescript
+    @OneToMany(() => Workspace, (workspace) => workspace.owner)
+    workspaces: Workspace[];
+    ```
+
+#### ManyToMany Relationships
+- Generates:
+  - Join table and array properties on both entities
+  - Example:
+    ```typescript
+    @ManyToMany(() => Tag, (tag) => tag.posts)
+    @JoinTable()
+    tags: Tag[];
+    ```
+- **Warning:** If you define both a ManyToMany relationship and an explicit join entity, you may get duplicate join tables and properties. Prefer one approach.
+
+### 3. Common Pitfalls and Solutions
+
+#### Duplicate Identifier Errors
+- **Cause:** Defining both sides of a relationship (bidirectional definitions)
+- **Solution:** Remove one side; only define the relationship once.
+
+#### "Property does not exist" Errors
+- **Cause:** Referencing an inverse property that was not generated (e.g., using a `to_name` that doesn't match)
+- **Solution:** Only use explicitly defined property names; check generated code for actual property names.
+
+#### "Multiple properties with same name" Errors
+- **Cause:** Complex or circular relationship chains, or duplicate relationship definitions
+- **Solution:** Simplify relationships, avoid deep nesting, and ensure each relationship is defined only once.
+
+#### ManyToMany + Explicit Join Entity Conflicts
+- **Cause:** Defining both a ManyToMany and a join entity for the same relationship
+- **Solution:** Use either a ManyToMany or a join entity, not both.
+
+#### Circular Eager Loading Issues
+- **Cause:** Deeply nested or circular relationships
+- **Solution:** Limit eager loading, use lazy relations, and avoid unnecessary deep nesting in your model.
+
+### 4. Relationship Patterns
+
+#### Multi-Tenant Architecture
+```json
+{ "from": "Resource", "to": "Workspace", "type": "ManyToOne", "to_name": "workspace" },
+{ "from": "Resource", "to": "User", "type": "ManyToOne", "to_name": "createdBy" }
+```
+
+#### Audit Trails, Deployment History, Optional Relationships
+```json
+{ "from": "Deployment", "to": "User", "type": "ManyToOne", "to_name": "deployedBy", "nullable": true },
+{ "from": "AuditLog", "to": "Resource", "type": "ManyToOne", "to_name": "resource" }
+```
+
+#### ManyToMany Example
+```json
+{ "from": "User", "to": "Role", "type": "ManyToMany", "to_name": "roles" }
+```
+
+### 5. Testing and Validation Guide
+
+- **Validate Relationship Generation:**
+  - After running `apso server scaffold`, inspect the generated entity files in the `autogen` directory (never modify these directly—see above for extension instructions).
+  - Check that only one property exists for each relationship per entity.
+  - Confirm that foreign key columns and decorators are present as expected.
+
+- **Build Testing Procedures:**
+  - Run `tsc` or your build process to catch duplicate or missing property errors early.
+  - Write unit tests for entity relationships if possible.
+
+- **Entity Inspection Checklist:**
+  - No duplicate properties or foreign keys
+  - All relationships have the correct decorators
+  - No circular imports or eager loading loops
+
+- **Clean Regeneration Practices:**
+  - Before re-scaffolding, remove old generated code:
+    ```sh
+    rm -rf autogen
+    apso server scaffold
+    ```
+  This prevents stale or duplicate files from causing errors. **Never add custom code to autogen—use extensions as described above.**
+
+### 6. Version 2 Format Clarity
+
+- In v2, relationships and entities are defined in separate arrays:
+  ```json
+  {
+    "version": 2,
+    "entities": [ ... ],
+    "relationships": [ ... ]
+  }
+  ```
+- Each relationship should only be defined once, with clear `to_name` if you want a custom property name.
+- Field types and validation are specified per the [Auto-Generated Code Reference](#auto-generated-code-reference).
+
+> **Summary:**
+>
+> - Only define one side of each relationship in `.apsorc`.
+> - Let Apso CLI auto-generate the inverse side.
+> - Avoid deep nesting and duplicate definitions.
+> - Always inspect generated code and test your build after scaffolding.
+
 ## Schema Reference
 
 The `.apsorc` file must conform to the [APSO Configuration Schema](./apsorc.schema.json). This schema defines all valid properties, types, and constraints for your configuration file.

package/dist/commands/server/scaffold.js

@@ -45,7 +45,7 @@ class Scaffold extends base_command_1.default {
             console.log(`[mem] heapUsed after createDto for ${entity.name}: ${(used.heapUsed / 1024 / 1024).toFixed(2)} MB`);
         }
         const tService = perf_hooks_1.performance.now();
-        await (0, lib_1.createService)(filePath, entity);
+        await (0, lib_1.createService)(filePath, entity, relationshipMap);
         if (process.env.DEBUG) {
             console.log(`[timing] createService for ${entity.name}: ${(perf_hooks_1.performance.now() - tService).toFixed(2)}ms`);
             const used = process.memoryUsage();

package/dist/lib/controller.js

@@ -58,7 +58,7 @@ const createController = async (apiBaseDir, entity, relationshipMap) => {
         nestedJoinsFile,
     };
     const startRenderController = perf_hooks_1.performance.now();
-    const controllerContent = await Eta.renderFileAsync("./rest/controller-rest", data);
+    const controllerContent = await Eta.renderFileAsync("./rest/controller-rest", (0, file_system_1.withGeneratedMeta)(data));
     const renderControllerTime = perf_hooks_1.performance.now() - startRenderController;
     if (process.env.DEBUG) {
         console.log(`[createController][${entityName}] renderController: ${renderControllerTime.toFixed(2)} ms`);
@@ -70,7 +70,7 @@ const createController = async (apiBaseDir, entity, relationshipMap) => {
         console.log(`[createController][${entityName}] writeController: ${writeControllerTime.toFixed(2)} ms`);
     }
     const startRenderSpec = perf_hooks_1.performance.now();
-    const specContent = await Eta.renderFileAsync("./rest/controller-rest-spec", data);
+    const specContent = await Eta.renderFileAsync("./rest/controller-rest-spec", (0, file_system_1.withGeneratedMeta)(data));
     const renderSpecTime = perf_hooks_1.performance.now() - startRenderSpec;
     if (process.env.DEBUG) {
         console.log(`[createController][${entityName}] renderSpec: ${renderSpecTime.toFixed(2)} ms`);

package/dist/lib/dto.js

@@ -74,7 +74,7 @@ options) => {
         importEnums: (0, field_1.typeExistsInEntity)(entity, "enum") !== -1,
     };
     // Render the unified template only once
-    const dtoContent = await Eta.renderFileAsync("./rest/dto-rest", data);
+    const dtoContent = await Eta.renderFileAsync("./rest/dto-rest", (0, file_system_1.withGeneratedMeta)(data));
     // Create only one DTO file
     await (0, file_system_1.createFile)(dtoFile, dtoContent);
 };

package/dist/lib/entity.js

@@ -44,7 +44,7 @@ const createEntity = async (apiBaseDir, entity, relationshipsNew, apiType) => {
         apiType,
     };
     const templatePath = apiType === "graphql" ? "./graphql/gql-entity-graphql" : "./entities/entity";
-    const content = await Eta.renderFileAsync(templatePath, data);
+    const content = await Eta.renderFileAsync(templatePath, (0, file_system_1.withGeneratedMeta)(data));
     await (0, file_system_1.createFile)(File, content);
 };
 exports.createEntity = createEntity;

package/dist/lib/service.d.ts

@@ -1,9 +1,2 @@
 import { Entity } from "./types";
-/**
- * Generates NestJS service and spec files for a given entity.
- *
- * @param apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
- * @param entity The entity definition object from the parsed .apsorc.
- * @returns {Promise<void>} A promise that resolves when the service and spec files are created.
- */
-export declare const createService: (apiBaseDir: string, entity: Entity) => Promise<void>;
+export declare const createService: (apiBaseDir: string, entity: Entity, relationshipMap?: any) => Promise<void>;

package/dist/lib/service.js

@@ -5,32 +5,56 @@ const tslib_1 = require("tslib");
 const Eta = tslib_1.__importStar(require("eta"));
 const file_system_1 = require("./utils/file-system");
 const path = tslib_1.__importStar(require("path"));
-/**
+/*
  * Generates NestJS service and spec files for a given entity.
  *
  * @param apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
  * @param entity The entity definition object from the parsed .apsorc.
  * @returns {Promise<void>} A promise that resolves when the service and spec files are created.
  */
-const createService = async (apiBaseDir, entity) => {
+const createService = async (apiBaseDir, entity, relationshipMap // RelationshipMap, optional for backward compatibility
+) => {
     const { name: entityName } = entity;
     const serviceFileName = path.join(apiBaseDir, `${entityName}.service.ts`);
     const specFileName = path.join(apiBaseDir, `${entityName}.service.spec.ts`);
     // Names needed by the templates
     const svcName = `${entityName}Service`;
     const repoName = `${entityName}Repository`; // Assuming convention
+    // --- NEW: Recursively collect all related entities for the test file ---
+    let allRelatedEntities = [entityName];
+    if (relationshipMap && relationshipMap[entityName]) {
+        // Use a Set to avoid duplicates
+        const visited = new Set();
+        const collect = (entity) => {
+            if (visited.has(entity))
+                return;
+            visited.add(entity);
+            allRelatedEntities.push(entity);
+            const rels = relationshipMap[entity] || [];
+            for (const rel of rels) {
+                if (!visited.has(rel.name)) {
+                    collect(rel.name);
+                }
+            }
+        };
+        allRelatedEntities = [];
+        collect(entityName);
+        // Remove self-duplicates using spread operator
+        allRelatedEntities = [...new Set(allRelatedEntities)];
+    }
     // Data for the Eta templates
     const data = {
         svcName,
         repoName,
         entityName,
+        allRelatedEntities,
     };
     // Render service template
-    const serviceContent = await Eta.renderFileAsync("./rest/service-rest", data);
+    const serviceContent = await Eta.renderFileAsync("./rest/service-rest", (0, file_system_1.withGeneratedMeta)(data));
     await (0, file_system_1.createFile)(serviceFileName, serviceContent);
     Eta.templates.remove("./rest/service-rest");
     // Render spec template
-    const specContent = await Eta.renderFileAsync("./rest/service-rest-spec", data);
+    const specContent = await Eta.renderFileAsync("./rest/service-rest-spec", (0, file_system_1.withGeneratedMeta)(data));
     await (0, file_system_1.createFile)(specFileName, specContent);
     Eta.templates.remove("./rest/service-rest-spec");
 };

package/dist/lib/templates/entities/entity-col-datetime.eta

@@ -0,0 +1,4 @@
+<% const {field} = it; %>
+
+@Column({ type: 'timestamp', nullable: <%= Boolean(field.nullable) %> })
+<%= field.name %>: Date; 

package/dist/lib/templates/entities/entity-col-geography.eta

@@ -0,0 +1,29 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@Column({
+  "type": "geography",
+  transformer: {
+    to: (geography: any) => {
+      if (!geography) return null;
+      return geography;
+    },
+    from: (pgGeography: any) => {
+      if (!pgGeography) return null;
+      return pgGeography;
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: any;