@apso/cli 0.1.9 → 0.3.0

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-decimal.eta

@@ -0,0 +1,4 @@
+<% const {field} = it; %>
+
+@Field(() => Number <% if (field.default !== null) {%>, { nullable: true } <% }%>)
+<%= field.name %>: <%= field.dataType %>; 

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-numeric.eta

@@ -0,0 +1,4 @@
+<% const {field} = it; %>
+
+@Field(() => Number <% if (field.default !== null) {%>, { nullable: true } <% }%>)
+<%= field.name %>: <%= field.dataType %>; 

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/header.eta

@@ -1,3 +1,8 @@
-/** 
- * This file generated by Apso.
-*/
+<% /*
+ * This file is generated by Apso.
+ *
+ * Generated at: <%= it.generatedAt %>
+ * Generated by: <%= it.generatedBy %>
+ *
+ * Do not edit this file directly.
+*/ %>

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

@@ -1,6 +1,7 @@
-import { ApiProperty } from '@nestjs/swagger';
 <%~ includeFile('./header.eta') %>
 
+import { ApiProperty } from '@nestjs/swagger';
+
 <% if (it.importEnums) { %>
 import * as enums from '../../enums';
 <% } %>
@@ -14,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 %>;
   <% } %>
@@ -33,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/templates/rest/ormconfig.eta

@@ -1,3 +1,5 @@
+<%~ includeFile('./header.eta') %>
+
 <% it.entities.forEach((entity) => { %>
 import {<%= entity.name %>} from './autogen/<%= entity.name %>/<%= entity.name %>.entity'
 <%}) %>

package/dist/lib/templates/rest/service-rest-spec.eta

@@ -1,7 +1,14 @@
+<%~ includeFile('./header.eta') %>
+
 import { Test, TestingModule } from '@nestjs/testing';
 import { <%= it.svcName %> } from './<%= it.entityName %>.service';
-import { getRepositoryToken } from '@nestjs/typeorm';
+import { TypeOrmModule } from '@nestjs/typeorm';
 import { <%= it.entityName %> } from './<%= it.entityName %>.entity';
+<% it.allRelatedEntities.forEach(function(entity) { if (entity !== it.entityName) { %>
+import { <%= entity %> } from '../<%= entity %>/<%= entity %>.entity';
+<% }}); %>
+
+// All related entities (including the main entity) are included below to ensure TypeORM can resolve relationships for this service's entity and its graph.
 
 describe('<%= it.svcName %>', () => {
   let service: <%= it.svcName %>;
@@ -18,13 +25,15 @@ describe('<%= it.svcName %>', () => {
     };
 
     const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        <%= it.svcName %>,
-        {
-          provide: getRepositoryToken(<%= it.entityName %>),
-          useValue: mockRepository,
-        },
+      imports: [
+        TypeOrmModule.forRoot({
+          // ...database config (provide your test DB config here)
+          entities: [<%= [it.entityName, ...it.allRelatedEntities.filter(e => e !== it.entityName)].join(', ') %>],
+          synchronize: true,
+        }),
+        TypeOrmModule.forFeature([<%= it.entityName %>]),
       ],
+      providers: [<%= it.svcName %>],
     }).compile();
 
     service = module.get<<%= it.svcName %>>(<%= it.svcName %>);

package/dist/lib/types/field.d.ts

@@ -1,4 +1,4 @@
-export type FieldType = "text" | "boolean" | "array" | "enum" | "integer" | "float" | "date" | "json" | "json-plain";
+export type FieldType = "text" | "boolean" | "array" | "enum" | "integer" | "float" | "decimal" | "numeric" | "date" | "json" | "json-plain";
 export interface Field {
     name: string;
     type: FieldType;
@@ -9,6 +9,8 @@ export interface Field {
     unique?: boolean;
     default?: string | null;
     length?: number;
+    precision?: number;
+    scale?: number;
     is_email?: boolean;
 }
 export interface ComputedField extends Field {

package/dist/lib/utils/field.d.ts

@@ -4,3 +4,4 @@ export declare const getDefaultValueForField: (field: Field) => string | null;
 export declare const getFieldForTemplate: (fields: Field[], entityName: string) => ComputedField[];
 export declare const fieldToEnumType: (fieldName: string, entityName: string) => string;
 export declare const typeExistsInEntity: (entity: Entity, type: string) => number;
+export declare const validateDecimalField: (field: Field) => void;

package/dist/lib/utils/field.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = void 0;
+exports.validateDecimalField = exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = void 0;
 const casing_1 = require("./casing");
 const typeToJsType = {
     array: "string[]",
@@ -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;
@@ -70,13 +79,17 @@ const getDefaultValueForField = (field) => {
     }
 };
 exports.getDefaultValueForField = getDefaultValueForField;
-const getFieldForTemplate = (fields, entityName) => fields.map((field) => ({
-    ...field,
-    default: (0, exports.getDefaultValueForField)(field),
-    dataType: field.type === "enum"
-        ? (0, exports.fieldToEnumType)(field.name, entityName)
-        : (0, exports.getJsTypeFromFieldType)(field.type),
-}));
+const getFieldForTemplate = (fields, entityName) => fields.map((field) => {
+    // Validate decimal/numeric fields
+    (0, exports.validateDecimalField)(field);
+    return {
+        ...field,
+        default: (0, exports.getDefaultValueForField)(field),
+        dataType: field.type === "enum"
+            ? (0, exports.fieldToEnumType)(field.name, entityName)
+            : (0, exports.getJsTypeFromFieldType)(field.type),
+    };
+});
 exports.getFieldForTemplate = getFieldForTemplate;
 const fieldToEnumType = (fieldName, entityName) => `${(0, casing_1.pascalCase)(entityName)}${(0, casing_1.pascalCase)(fieldName)}Enum`;
 exports.fieldToEnumType = fieldToEnumType;
@@ -84,3 +97,23 @@ const typeExistsInEntity = (entity, type) => (entity === null || entity === void
     ? entity === null || entity === void 0 ? void 0 : entity.fields.findIndex((field) => field.type === type)
     : -1;
 exports.typeExistsInEntity = typeExistsInEntity;
+const validateDecimalField = (field) => {
+    if (field.type !== "decimal" && field.type !== "numeric") {
+        return;
+    }
+    // Validate precision
+    if (field.precision !== undefined && (field.precision < 1 || field.precision > 131072)) {
+        throw new Error(`${field.name}: Invalid precision value ${field.precision}. Must be between 1 and 131072.`);
+    }
+    // Validate scale
+    if (field.scale !== undefined) {
+        if (field.scale < 0 || field.scale > 16383) {
+            throw new Error(`${field.name}: Invalid scale value ${field.scale}. Must be between 0 and 16383.`);
+        }
+        // Validate that scale doesn't exceed precision
+        if (field.precision !== undefined && field.scale > field.precision) {
+            throw new Error(`${field.name}: Scale (${field.scale}) cannot be greater than precision (${field.precision}).`);
+        }
+    }
+};
+exports.validateDecimalField = validateDecimalField;

package/dist/lib/utils/file-system.d.ts

@@ -1,2 +1,6 @@
 export declare const createFile: (file: string, content: string) => Promise<void>;
 export declare const createDirectoryContents: (templatePath: string, newProjectPath: string, apiType: string) => void;
+export declare function withGeneratedMeta<T extends object>(data: T): T & {
+    generatedAt: string;
+    generatedBy: string;
+};

package/dist/lib/utils/file-system.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDirectoryContents = exports.createFile = void 0;
+exports.withGeneratedMeta = exports.createDirectoryContents = exports.createFile = void 0;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const fs = tslib_1.__importStar(require("fs"));
@@ -50,3 +50,11 @@ const writeFile = (fileName, origFilePath, writePath, mode, apiType) => {
         fs.chmodSync(fileWritePath, mode);
     }
 };
+function withGeneratedMeta(data) {
+    return {
+        ...data,
+        generatedAt: new Date().toISOString(),
+        generatedBy: process.env.USER || process.env.USERNAME || 'unknown',
+    };
+}
+exports.withGeneratedMeta = withGeneratedMeta;

package/dist/lib/utils/relationships/parse.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelationshipsForImport = exports.streamNestedRelationships = exports.getNestedRelationships = exports.generateNestedRelationships = exports.getRelationshipForTemplate = exports.getRelationshipIdField = exports.parseRelationships = exports.parseRelationship = exports.parseManyToMany = exports.parseManytoOne = exports.parseOneToMany = void 0;
 const tslib_1 = require("tslib");
 const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
-const casing_1 = require("../../utils/casing");
+const casing_1 = require("../casing");
 /**
  * Parses a OneToMany relationship definition.
  * These are treated as bidirectional from the .apsorc definition.

package/dist/tests/templates/entities/types/decimal-field-validation.spec.d.ts

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