@apso/cli 0.2.0 → 0.3.1

package/README.md

@@ -305,6 +305,12 @@ This section details the code that Apso CLI automatically generates from your `.
 
 ### 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)`        |
@@ -315,6 +321,15 @@ This section details the code that Apso CLI automatically generates from your `.
 | `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
 
@@ -352,6 +367,115 @@ Generates:
 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:

package/dist/commands/server/new.d.ts

@@ -10,13 +10,13 @@ export default class New extends BaseCommand {
     static args: {
         name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
     };
-    installModules(path: string): Promise<void>;
-    formatApp(root: string): Promise<void>;
-    startApp(root: string): Promise<void>;
+    installModules(projectPath: string): Promise<void>;
+    formatApp(projectPath: string): Promise<void>;
+    startApp(projectPath: string): Promise<void>;
     cloneTemplate(projectPath: string): Promise<void>;
-    run(): Promise<void>;
     validateFlags(): Promise<{
         projectName: string;
         apiType: string;
     }>;
+    run(): Promise<void>;
 }

package/dist/commands/server/new.js

@@ -12,28 +12,25 @@ class New extends base_command_1.default {
         super(...arguments);
         this.CURR_DIR = process.cwd();
     }
-    async installModules(path) {
-        this.log("installing modules");
-        await this.runNpmCommand(["install", "--force", "--prefix", path]);
+    async installModules(projectPath) {
+        this.log("Installing modules...");
+        await this.runNpmCommand(["install", "--force", "--prefix", projectPath]);
     }
-    async formatApp(root) {
-        this.log("cleaning up");
-        shelljs_1.default.cd(root);
-        await this.runNpmCommand(["run", "format", "--prefix", root]);
+    async formatApp(projectPath) {
+        this.log("Formatting code...");
+        shelljs_1.default.cd(projectPath);
+        await this.runNpmCommand(["run", "format", "--prefix", projectPath]);
     }
-    async startApp(root) {
+    async startApp(projectPath) {
         return new Promise((resolve, reject) => {
-            const command = "npm";
+            const isWindows = process.platform === "win32";
+            const command = isWindows ? "npm.cmd" : "npm";
             const args = ["start"];
-            // Explicitly set cwd() to work around issues like
-            // https://github.com/facebook/create-react-app/issues/3326.
-            // Unfortunately we can only do this for Yarn because npm support for
-            // equivalent --prefix flag doesn't help with this issue.
-            // This is why for npm, we run checkThatNpmCanReadCwd() early instead.
-            // args.push('--cwd')
-            // args.push(root)
-            // args.push('--verbose')
-            const child = (0, child_process_1.spawn)(command, args, { stdio: "inherit", cwd: root });
+            const child = (0, child_process_1.spawn)(command, args, {
+                cwd: projectPath,
+                stdio: "inherit",
+                shell: isWindows,
+            });
             child.on("close", (code) => {
                 if (code !== 0) {
                     reject({
@@ -43,15 +40,18 @@ class New extends base_command_1.default {
                 }
                 resolve();
             });
+            child.on("error", (err) => {
+                this.log(`Error starting app: ${err.message}`);
+                reject(err);
+            });
         });
     }
     async cloneTemplate(projectPath) {
-        this.log("Creating project in current folder.");
+        this.log("Cloning service template...");
         if (!fs.existsSync(projectPath) && this.CURR_DIR !== projectPath) {
             fs.mkdirSync(projectPath);
         }
         shelljs_1.default.cd(projectPath);
-        // Execute git clone and capture the result using HTTPS
         const cloneResult = shelljs_1.default.exec(`git clone --depth=1 --branch=main https://github.com/apsoai/service-template.git ${projectPath}`, { silent: true }); // Use silent: true to suppress default output
         // Check if the command failed
         if (cloneResult.code !== 0) {
@@ -66,34 +66,31 @@ class New extends base_command_1.default {
         shelljs_1.default.exec(`rm -rf ${projectPath}/.git`);
         shelljs_1.default.cd(this.CURR_DIR);
     }
-    async run() {
-        this.log("Initializing New Apso Server...");
-        const { projectName,
-        // apiType,
-         } = await this.validateFlags();
-        const CURR_DIR = process.cwd();
-        const projectPath = path.join(CURR_DIR, projectName);
-        await this.cloneTemplate(projectPath);
-        await this.installModules(projectPath);
-        await this.formatApp(projectPath);
-    }
     async validateFlags() {
         var _a;
         const { flags } = await this.parse(New);
         let projectName = flags.name;
         let apiType = (_a = flags.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        if (typeof projectName === "undefined") {
-            // this.error("`name` must be set (e.g. WoofyApp)");
+        if (!projectName) {
             projectName = '';
         }
-        if (typeof apiType === "undefined") {
+        if (!apiType) {
             apiType = "rest";
         }
-        if (apiType !== "rest" && apiType !== "graphql") {
-            this.error("`apiType` must be set (e.g. rest or graphql)");
+        if (!["rest", "graphql"].includes(apiType)) {
+            this.error("`apiType` must be 'rest' or 'graphql'");
         }
         return { projectName, apiType };
     }
+    async run() {
+        this.log("Initializing New Apso Server...");
+        const { projectName } = await this.validateFlags();
+        const CURR_DIR = process.cwd();
+        const projectPath = path.join(CURR_DIR, projectName);
+        await this.cloneTemplate(projectPath);
+        await this.installModules(projectPath);
+        await this.formatApp(projectPath);
+    }
 }
 New.description = "Initialize your server project";
 New.examples = [`$ apso server new --name TestProject`];

package/dist/lib/base-command.js

@@ -1,23 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
+const os_1 = tslib_1.__importDefault(require("os"));
 class BaseCommand extends core_1.Command {
     async runNpmCommand(args, silent = false) {
         return new Promise((resolve, reject) => {
-            const command = "npm";
+            const isWindows = os_1.default.platform() === "win32";
+            const command = isWindows ? "npm.cmd" : "npm";
             const cmdStr = `${command} ${args.join(" ")}`;
-            this.log(cmdStr);
-            const child = (0, child_process_1.spawn)(command, args, { stdio: silent ? "ignore" : "inherit" });
+            this.log(`Running: ${cmdStr}`);
+            const child = (0, child_process_1.spawn)(command, args, {
+                stdio: "inherit",
+                shell: isWindows,
+            });
             child.on("close", (code) => {
                 if (code !== 0) {
-                    reject({
-                        command: cmdStr,
-                    });
+                    reject({ command: cmdStr, exitCode: code });
                     return;
                 }
                 resolve();
             });
+            child.on("error", () => {
+                this.error(`Failed to run: ${cmdStr}`);
+            });
         });
     }
 }

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; 

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

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

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

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

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

@@ -0,0 +1,37 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@Column({
+  "type": "linestring",
+  transformer: {
+    to: (linestring: { coordinates: Array<{x: number, y: number}> } | null) => {
+      if (!linestring) return null;
+      const coords = linestring.coordinates.map(coord => `${coord.x} ${coord.y}`).join(',');
+      return `LINESTRING(${coords})`;
+    },
+    from: (pgLinestring: string | null) => {
+      if (!pgLinestring) return null;
+      // Extract coordinates from LINESTRING(x1 y1,x2 y2,...) format
+      const match = pgLinestring.match(/LINESTRING\((.+)\)/);
+      if (!match) return null;
+      const coords = match[1].split(',').map(coord => {
+        const [x, y] = coord.trim().split(' ');
+        return { x: parseFloat(x), y: parseFloat(y) };
+      });
+      return { coordinates: coords };
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: { coordinates: Array<{ x: number, y: number }> }; 

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

@@ -0,0 +1,44 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@Column({
+  "type": "multilinestring",
+  transformer: {
+    to: (multilinestring: { coordinates: Array<Array<{x: number, y: number}>> } | null) => {
+      if (!multilinestring) return null;
+      const linestrings = multilinestring.coordinates.map(linestring => {
+        const coords = linestring.map(coord => `${coord.x} ${coord.y}`).join(',');
+        return `(${coords})`;
+      });
+      return `MULTILINESTRING(${linestrings.join(',')})`;
+    },
+    from: (pgMultilinestring: string | null) => {
+      if (!pgMultilinestring) return null;
+      // Extract coordinates from MULTILINESTRING((x1 y1,x2 y2,...),(x1 y1,x2 y2,...)) format
+      const match = pgMultilinestring.match(/MULTILINESTRING\((.+)\)/);
+      if (!match) return null;
+      const linestrings = match[1].split('),(').map(linestring => {
+        const cleanLinestring = linestring.replace(/[()]/g, '');
+        const coords = cleanLinestring.split(',').map(coord => {
+          const [x, y] = coord.trim().split(' ');
+          return { x: parseFloat(x), y: parseFloat(y) };
+        });
+        return coords;
+      });
+      return { coordinates: linestrings };
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> }; 

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

@@ -0,0 +1,37 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@Column({
+  "type": "multipoint",
+  transformer: {
+    to: (multipoint: { coordinates: Array<{x: number, y: number}> } | null) => {
+      if (!multipoint) return null;
+      const coords = multipoint.coordinates.map(coord => `${coord.x} ${coord.y}`).join(',');
+      return `MULTIPOINT(${coords})`;
+    },
+    from: (pgMultipoint: string | null) => {
+      if (!pgMultipoint) return null;
+      // Extract coordinates from MULTIPOINT(x1 y1,x2 y2,...) format
+      const match = pgMultipoint.match(/MULTIPOINT\((.+)\)/);
+      if (!match) return null;
+      const coords = match[1].split(',').map(coord => {
+        const [x, y] = coord.trim().split(' ');
+        return { x: parseFloat(x), y: parseFloat(y) };
+      });
+      return { coordinates: coords };
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: { coordinates: Array<{ x: number, y: number }> }; 

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

@@ -0,0 +1,50 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@Column({
+  "type": "multipolygon",
+  transformer: {
+    to: (multipolygon: { coordinates: Array<Array<Array<{x: number, y: number}>>> } | null) => {
+      if (!multipolygon) return null;
+      const polygons = multipolygon.coordinates.map(polygon => {
+        const rings = polygon.map(ring => {
+          const coords = ring.map(coord => `${coord.x} ${coord.y}`).join(',');
+          return `(${coords})`;
+        });
+        return `(${rings.join(',')})`;
+      });
+      return `MULTIPOLYGON(${polygons.join(',')})`;
+    },
+    from: (pgMultipolygon: string | null) => {
+      if (!pgMultipolygon) return null;
+      // Extract coordinates from MULTIPOLYGON(((x1 y1,x2 y2,...),(x1 y1,x2 y2,...)),((x1 y1,x2 y2,...),(x1 y1,x2 y2,...))) format
+      const match = pgMultipolygon.match(/MULTIPOLYGON\((.+)\)/);
+      if (!match) return null;
+      const polygons = match[1].split(')),((').map(polygon => {
+        const cleanPolygon = polygon.replace(/[()]/g, '');
+        const rings = cleanPolygon.split('),(').map(ring => {
+          const coords = ring.split(',').map(coord => {
+            const [x, y] = coord.trim().split(' ');
+            return { x: parseFloat(x), y: parseFloat(y) };
+          });
+          return coords;
+        });
+        return rings;
+      });
+      return { coordinates: polygons };
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> }; 

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

@@ -0,0 +1,44 @@
+<% const {field} = it; %>
+
+@IsOptional({ groups: [UPDATE] })
+<% if (!field.nullable && !field.auto) { %>
+@IsNotEmpty({ groups: [CREATE] })
+<% } %>
+
+@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;
+      // Extract coordinates from POLYGON((x1 y1,x2 y2,...),(x1 y1,x2 y2,...)) format
+      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 };
+    }
+  }<% if (field.nullable) {%>,
+  nullable: true<% } %>
+})
+<% if (field.index ) {%>
+@Index()
+<% } %>
+<% if (field.primary ) {%>
+@PrimaryColumn()
+<% } %>
+
+<%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> }; 

package/dist/lib/templates/graphql/dto/dto-col-geography.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: any; 

package/dist/lib/templates/graphql/dto/dto-col-geometry.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: any; 

package/dist/lib/templates/graphql/dto/dto-col-geometrycollection.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { geometries: Array<any> }; 

package/dist/lib/templates/graphql/dto/dto-col-linestring.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { coordinates: Array<{ x: number, y: number }> }; 

package/dist/lib/templates/graphql/dto/dto-col-multilinestring.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> }; 

package/dist/lib/templates/graphql/dto/dto-col-multipoint.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { coordinates: Array<{ x: number, y: number }> }; 

package/dist/lib/templates/graphql/dto/dto-col-multipolygon.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> }; 

package/dist/lib/templates/graphql/dto/dto-col-point.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { x: number, y: number }; 

package/dist/lib/templates/graphql/dto/dto-col-polygon.eta

@@ -0,0 +1,4 @@
+<% const {field, isGql} = it; %>
+
+@Field(() => JSONResolver, { nullable: true })
+<%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> }; 

package/dist/lib/templates/rest/dto-rest.eta

@@ -15,6 +15,18 @@ export class <%= it.entityName %>Create {
     <%= field.name %>: JSON;
   <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
     <%= field.name %>: Date;
+  <%} else if (field.type === 'geometry' || field.type === 'geography') {%>
+    <%= field.name %>: any;
+  <%} else if (field.type === 'point') {%>
+    <%= field.name %>: { x: number, y: number };
+  <%} else if (field.type === 'linestring' || field.type === 'multipoint') {%>
+    <%= field.name %>: { coordinates: Array<{ x: number, y: number }> };
+  <%} else if (field.type === 'polygon' || field.type === 'multilinestring') {%>
+    <%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> };
+  <%} else if (field.type === 'multipolygon') {%>
+    <%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> };
+  <%} else if (field.type === 'geometrycollection') {%>
+    <%= field.name %>: { geometries: Array<any> };
   <%} else {%>
     <%= field.name %>: <%= field.dataType %>;
   <% } %>
@@ -34,6 +46,18 @@ export class <%= it.entityName %> {
     <%= field.name %>: JSON;
   <%} else if (field.type === 'timestamp' || field.type === 'timestamptz') {%>
     <%= field.name %>: Date;
+  <%} else if (field.type === 'geometry' || field.type === 'geography') {%>
+    <%= field.name %>: any;
+  <%} else if (field.type === 'point') {%>
+    <%= field.name %>: { x: number, y: number };
+  <%} else if (field.type === 'linestring' || field.type === 'multipoint') {%>
+    <%= field.name %>: { coordinates: Array<{ x: number, y: number }> };
+  <%} else if (field.type === 'polygon' || field.type === 'multilinestring') {%>
+    <%= field.name %>: { coordinates: Array<Array<{ x: number, y: number }>> };
+  <%} else if (field.type === 'multipolygon') {%>
+    <%= field.name %>: { coordinates: Array<Array<Array<{ x: number, y: number }>>> };
+  <%} else if (field.type === 'geometrycollection') {%>
+    <%= field.name %>: { geometries: Array<any> };
   <%} else {%>
     <%= field.name %>: <%= field.dataType %>;
   <% } %>

package/dist/lib/utils/field.js

@@ -36,7 +36,16 @@ const typeToJsType = {
     bytea: "Buffer",
     point: "{ x: number, y: number }",
     int4range: "{ lower: number, upper: number, lowerInclusive: boolean, upperInclusive: boolean }",
-    enum: "string", // handled elsewhere for custom enums
+    enum: "string",
+    // PostGIS data types
+    geometry: "any",
+    geography: "any",
+    linestring: "{ coordinates: Array<{ x: number, y: number }> }",
+    polygon: "{ coordinates: Array<Array<{ x: number, y: number }>> }",
+    multipoint: "{ coordinates: Array<{ x: number, y: number }> }",
+    multilinestring: "{ coordinates: Array<Array<{ x: number, y: number }>> }",
+    multipolygon: "{ coordinates: Array<Array<Array<{ x: number, y: number }>>> }",
+    geometrycollection: "{ geometries: Array<any> }",
 };
 const getJsTypeFromFieldType = (type) => { var _a; return (_a = typeToJsType[type]) !== null && _a !== void 0 ? _a : "string"; };
 exports.getJsTypeFromFieldType = getJsTypeFromFieldType;

package/dist/tests/templates/entities/types/geometry-template.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/templates/entities/types/geometry-template.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const template_test_utils_1 = require("../utils/template-test-utils");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)('Geometry Entity Template Tests', () => {
+    // Setup Eta configuration once before all tests
+    (0, globals_1.beforeAll)(() => {
+        (0, template_test_utils_1.configureEta)();
+    });
+    const templatePath = './entities/entity-col-geometry';
+    const testCases = [
+        {
+            name: 'should render basic geometry field correctly',
+            field: {
+                name: 'shape',
+                dataType: 'any',
+                nullable: false
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({' },
+                { type: 'contains', text: '"type": "geometry"' },
+                { type: 'contains', text: 'transformer: {' },
+                { type: 'contains', text: 'to: (geometry: any) => {' },
+                { type: 'contains', text: 'from: (pgGeometry: any) => {' },
+                { type: 'contains', text: 'shape: any;' },
+                { type: 'notContains', text: 'nullable: true' }
+            ]
+        },
+        {
+            name: 'should render nullable geometry field correctly',
+            field: {
+                name: 'optionalShape',
+                dataType: 'any',
+                nullable: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({' },
+                { type: 'contains', text: '"type": "geometry"' },
+                { type: 'contains', text: 'nullable: true' },
+                { type: 'contains', text: 'optionalShape: any;' }
+            ]
+        },
+        {
+            name: 'should render indexed geometry field correctly',
+            field: {
+                name: 'spatialData',
+                dataType: 'any',
+                nullable: false,
+                index: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Index()' },
+                { type: 'contains', text: 'spatialData: any;' }
+            ]
+        }
+    ];
+    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
+});

package/dist/tests/templates/entities/types/polygon-template.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/templates/entities/types/polygon-template.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const template_test_utils_1 = require("../utils/template-test-utils");
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)('Polygon Entity Template Tests', () => {
+    // Setup Eta configuration once before all tests
+    (0, globals_1.beforeAll)(() => {
+        (0, template_test_utils_1.configureEta)();
+    });
+    const templatePath = './entities/entity-col-polygon';
+    const testCases = [
+        {
+            name: 'should render basic polygon field correctly',
+            field: {
+                name: 'boundary',
+                dataType: '{ coordinates: Array<Array<{ x: number, y: number }>> }',
+                nullable: false
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({' },
+                { type: 'contains', text: '"type": "polygon"' },
+                { type: 'contains', text: 'transformer: {' },
+                { type: 'contains', text: 'to: (polygon: { coordinates: Array<Array<{x: number, y: number}>> } | null) => {' },
+                { type: 'contains', text: 'from: (pgPolygon: string | null) => {' },
+                { type: 'contains', text: 'boundary: { coordinates: Array<Array<{ x: number, y: number }>> };' },
+                { type: 'notContains', text: 'nullable: true' }
+            ]
+        },
+        {
+            name: 'should render nullable polygon field correctly',
+            field: {
+                name: 'optionalBoundary',
+                dataType: '{ coordinates: Array<Array<{ x: number, y: number }>> }',
+                nullable: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({' },
+                { type: 'contains', text: '"type": "polygon"' },
+                { type: 'contains', text: 'nullable: true' },
+                { type: 'contains', text: 'optionalBoundary: { coordinates: Array<Array<{ x: number, y: number }>> };' }
+            ]
+        },
+        {
+            name: 'should render indexed polygon field correctly',
+            field: {
+                name: 'area',
+                dataType: '{ coordinates: Array<Array<{ x: number, y: number }>> }',
+                nullable: false,
+                index: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Index()' },
+                { type: 'contains', text: 'area: { coordinates: Array<Array<{ x: number, y: number }>> };' }
+            ]
+        }
+    ];
+    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
+});

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.0",
+  "version": "0.3.1",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",
   "bin": {