@apso/cli 0.5.0 → 0.6.0

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

@@ -2,55 +2,55 @@
 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)('Date Entity Template Tests', () => {
+(0, globals_1.describe)("Date 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-date';
+    const templatePath = "./entities/entity-col-date";
     const testCases = [
         {
-            name: 'should render basic date field correctly',
+            name: "should render basic date field correctly",
             field: {
-                name: 'birthDate',
-                dataType: 'Date',
-                nullable: false
+                name: "birthDate",
+                dataType: "Date",
+                nullable: false,
             },
             assertions: [
-                { type: 'contains', text: "@Column({ type: 'date'" },
-                { type: 'contains', text: 'nullable: false' },
-                { type: 'contains', text: 'birthDate: string;' },
-                { type: 'notContains', text: '@Index()' }
-            ]
+                { type: "contains", text: "@Column({ type: 'date'" },
+                { type: "contains", text: "nullable: false" },
+                { type: "contains", text: "birthDate: string;" },
+                { type: "notContains", text: "@Index()" },
+            ],
         },
         {
-            name: 'should render nullable date field correctly',
+            name: "should render nullable date field correctly",
             field: {
-                name: 'optionalDate',
-                dataType: 'Date',
-                nullable: true
+                name: "optionalDate",
+                dataType: "Date",
+                nullable: true,
             },
             assertions: [
-                { type: 'contains', text: "@Column({ type: 'date'" },
-                { type: 'contains', text: 'nullable: true' },
-                { type: 'contains', text: 'optionalDate: string;' }
-            ]
+                { type: "contains", text: "@Column({ type: 'date'" },
+                { type: "contains", text: "nullable: true" },
+                { type: "contains", text: "optionalDate: string;" },
+            ],
         },
         {
-            name: 'should render indexed date field correctly',
+            name: "should render indexed date field correctly",
             field: {
-                name: 'indexedDate',
-                dataType: 'Date',
+                name: "indexedDate",
+                dataType: "Date",
                 nullable: false,
-                index: true
+                index: true,
             },
             assertions: [
-                { type: 'contains', text: "@Column({ type: 'date'" },
-                { type: 'contains', text: 'nullable: false' },
-                { type: 'contains', text: '@Index()' },
-                { type: 'contains', text: 'indexedDate: string;' }
-            ]
-        }
+                { type: "contains", text: "@Column({ type: 'date'" },
+                { type: "contains", text: "nullable: false" },
+                { type: "contains", text: "@Index()" },
+                { type: "contains", text: "indexedDate: string;" },
+            ],
+        },
     ];
     (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
 });

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

@@ -2,98 +2,98 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const field_1 = require("../../../../lib/utils/field");
 const globals_1 = require("@jest/globals");
-(0, globals_1.describe)('Decimal Field Validation Tests', () => {
-    (0, globals_1.it)('should accept valid decimal field with precision and scale', () => {
+(0, globals_1.describe)("Decimal Field Validation Tests", () => {
+    (0, globals_1.it)("should accept valid decimal field with precision and scale", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 10,
             scale: 2,
-            nullable: false
+            nullable: false,
         };
         (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).not.toThrow();
     });
-    (0, globals_1.it)('should accept valid numeric field with precision and scale', () => {
+    (0, globals_1.it)("should accept valid numeric field with precision and scale", () => {
         const field = {
-            name: 'amount',
-            type: 'numeric',
+            name: "amount",
+            type: "numeric",
             precision: 16,
             scale: 6,
-            nullable: false
+            nullable: false,
         };
         (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).not.toThrow();
     });
-    (0, globals_1.it)('should accept decimal field without precision and scale (uses defaults)', () => {
+    (0, globals_1.it)("should accept decimal field without precision and scale (uses defaults)", () => {
         const field = {
-            name: 'value',
-            type: 'decimal',
-            nullable: false
+            name: "value",
+            type: "decimal",
+            nullable: false,
         };
         (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).not.toThrow();
     });
-    (0, globals_1.it)('should throw error for invalid precision (too low)', () => {
+    (0, globals_1.it)("should throw error for invalid precision (too low)", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 0,
             scale: 2,
-            nullable: false
+            nullable: false,
         };
-        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow('price: Invalid precision value 0. Must be between 1 and 131072.');
+        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow("price: Invalid precision value 0. Must be between 1 and 131072.");
     });
-    (0, globals_1.it)('should throw error for invalid precision (too high)', () => {
+    (0, globals_1.it)("should throw error for invalid precision (too high)", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 200000,
             scale: 2,
-            nullable: false
+            nullable: false,
         };
-        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow('price: Invalid precision value 200000. Must be between 1 and 131072.');
+        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow("price: Invalid precision value 200000. Must be between 1 and 131072.");
     });
-    (0, globals_1.it)('should throw error for invalid scale (too low)', () => {
+    (0, globals_1.it)("should throw error for invalid scale (too low)", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 10,
             scale: -1,
-            nullable: false
+            nullable: false,
         };
-        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow('price: Invalid scale value -1. Must be between 0 and 16383.');
+        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow("price: Invalid scale value -1. Must be between 0 and 16383.");
     });
-    (0, globals_1.it)('should throw error for invalid scale (too high)', () => {
+    (0, globals_1.it)("should throw error for invalid scale (too high)", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 10,
             scale: 20000,
-            nullable: false
+            nullable: false,
         };
-        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow('price: Invalid scale value 20000. Must be between 0 and 16383.');
+        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow("price: Invalid scale value 20000. Must be between 0 and 16383.");
     });
-    (0, globals_1.it)('should throw error when scale exceeds precision', () => {
+    (0, globals_1.it)("should throw error when scale exceeds precision", () => {
         const field = {
-            name: 'price',
-            type: 'decimal',
+            name: "price",
+            type: "decimal",
             precision: 5,
             scale: 10,
-            nullable: false
+            nullable: false,
         };
-        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow('price: Scale (10) cannot be greater than precision (5).');
+        (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).toThrow("price: Scale (10) cannot be greater than precision (5).");
     });
-    (0, globals_1.it)('should not validate non-decimal fields', () => {
+    (0, globals_1.it)("should not validate non-decimal fields", () => {
         const field = {
-            name: 'name',
-            type: 'text',
-            nullable: false
+            name: "name",
+            type: "text",
+            nullable: false,
         };
         (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).not.toThrow();
     });
-    (0, globals_1.it)('should not validate non-numeric fields', () => {
+    (0, globals_1.it)("should not validate non-numeric fields", () => {
         const field = {
-            name: 'active',
-            type: 'boolean',
-            nullable: false
+            name: "active",
+            type: "boolean",
+            nullable: false,
         };
         (0, globals_1.expect)(() => (0, field_1.validateDecimalField)(field)).not.toThrow();
     });

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

@@ -2,85 +2,85 @@
 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)('Decimal Entity Template Tests', () => {
+(0, globals_1.describe)("Decimal 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-decimal';
+    const templatePath = "./entities/entity-col-decimal";
     const testCases = [
         {
-            name: 'should render basic decimal field correctly',
+            name: "should render basic decimal field correctly",
             field: {
-                name: 'price',
-                dataType: 'number',
-                nullable: false
+                name: "price",
+                dataType: "number",
+                nullable: false,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "decimal"' },
-                { type: 'contains', text: 'precision: 10' },
-                { type: 'contains', text: 'scale: 2' },
-                { type: 'contains', text: 'price: number;' },
-                { type: 'notContains', text: '@Index()' },
-                { type: 'notContains', text: '@PrimaryColumn()' }
-            ]
+                { type: "contains", text: '@Column({ "type": "decimal"' },
+                { type: "contains", text: "precision: 10" },
+                { type: "contains", text: "scale: 2" },
+                { type: "contains", text: "price: number;" },
+                { type: "notContains", text: "@Index()" },
+                { type: "notContains", text: "@PrimaryColumn()" },
+            ],
         },
         {
-            name: 'should render nullable decimal field correctly',
+            name: "should render nullable decimal field correctly",
             field: {
-                name: 'optionalPrice',
-                dataType: 'number',
-                nullable: true
+                name: "optionalPrice",
+                dataType: "number",
+                nullable: true,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "decimal"' },
-                { type: 'contains', text: 'optionalPrice: number;' }
-            ]
+                { type: "contains", text: '@Column({ "type": "decimal"' },
+                { type: "contains", text: "optionalPrice: number;" },
+            ],
         },
         {
-            name: 'should render decimal field with custom precision and scale',
+            name: "should render decimal field with custom precision and scale",
             field: {
-                name: 'amount',
-                dataType: 'number',
+                name: "amount",
+                dataType: "number",
                 nullable: false,
                 precision: 16,
-                scale: 6
+                scale: 6,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "decimal"' },
-                { type: 'contains', text: 'precision: 16' },
-                { type: 'contains', text: 'scale: 6' },
-                { type: 'contains', text: 'amount: number;' }
-            ]
+                { type: "contains", text: '@Column({ "type": "decimal"' },
+                { type: "contains", text: "precision: 16" },
+                { type: "contains", text: "scale: 6" },
+                { type: "contains", text: "amount: number;" },
+            ],
         },
         {
-            name: 'should render decimal field with default value correctly',
+            name: "should render decimal field with default value correctly",
             field: {
-                name: 'defaultPrice',
-                dataType: 'number',
+                name: "defaultPrice",
+                dataType: "number",
                 nullable: false,
-                default: '0.00'
+                default: "0.00",
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "decimal"' },
-                { type: 'contains', text: 'default:  0.00' },
-                { type: 'contains', text: 'defaultPrice: number;' }
-            ]
+                { type: "contains", text: '@Column({ "type": "decimal"' },
+                { type: "contains", text: "default:  0.00" },
+                { type: "contains", text: "defaultPrice: number;" },
+            ],
         },
         {
-            name: 'should render indexed decimal field correctly',
+            name: "should render indexed decimal field correctly",
             field: {
-                name: 'indexedPrice',
-                dataType: 'number',
+                name: "indexedPrice",
+                dataType: "number",
                 nullable: false,
-                index: true
+                index: true,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "decimal"' },
-                { type: 'contains', text: '@Index()' },
-                { type: 'contains', text: 'indexedPrice: number;' }
-            ]
-        }
+                { type: "contains", text: '@Column({ "type": "decimal"' },
+                { type: "contains", text: "@Index()" },
+                { type: "contains", text: "indexedPrice: number;" },
+            ],
+        },
     ];
     (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
 });

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

@@ -2,66 +2,69 @@
 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)('Double Entity Template Tests', () => {
+(0, globals_1.describe)("Double 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-double';
+    const templatePath = "./entities/entity-col-double";
     const testCases = [
         {
-            name: 'should render basic double field correctly',
+            name: "should render basic double field correctly",
             field: {
-                name: 'doubleValue',
-                dataType: 'number',
-                nullable: false
+                name: "doubleValue",
+                dataType: "number",
+                nullable: false,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "float8"' },
-                { type: 'contains', text: 'doubleValue: number;' },
-                { type: 'notContains', text: '@Index()' },
-                { type: 'notContains', text: '@PrimaryColumn()' }
-            ]
+                { type: "contains", text: '@Column({ "type": "float8"' },
+                { type: "contains", text: "doubleValue: number;" },
+                { type: "notContains", text: "@Index()" },
+                { type: "notContains", text: "@PrimaryColumn()" },
+            ],
         },
         {
-            name: 'should render nullable double field correctly',
+            name: "should render nullable double field correctly",
             field: {
-                name: 'optionalDouble',
-                dataType: 'number',
-                nullable: true
+                name: "optionalDouble",
+                dataType: "number",
+                nullable: true,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "float8"' },
-                { type: 'contains', text: 'optionalDouble: number;' }
-            ]
+                { type: "contains", text: '@Column({ "type": "float8"' },
+                { type: "contains", text: "optionalDouble: number;" },
+            ],
         },
         {
-            name: 'should render double field with default value correctly',
+            name: "should render double field with default value correctly",
             field: {
-                name: 'defaultDouble',
-                dataType: 'number',
+                name: "defaultDouble",
+                dataType: "number",
                 nullable: false,
-                default: 0
+                default: 0,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "float8", default:  0 })' },
-                { type: 'contains', text: 'defaultDouble: number;' }
-            ]
+                {
+                    type: "contains",
+                    text: '@Column({ "type": "float8", default:  0 })',
+                },
+                { type: "contains", text: "defaultDouble: number;" },
+            ],
         },
         {
-            name: 'should render indexed double field correctly',
+            name: "should render indexed double field correctly",
             field: {
-                name: 'indexedDouble',
-                dataType: 'number',
+                name: "indexedDouble",
+                dataType: "number",
                 nullable: false,
-                index: true
+                index: true,
             },
             assertions: [
-                { type: 'contains', text: '@Column({ "type": "float8"' },
-                { type: 'contains', text: '@Index()' },
-                { type: 'contains', text: 'indexedDouble: number;' }
-            ]
-        }
+                { type: "contains", text: '@Column({ "type": "float8"' },
+                { type: "contains", text: "@Index()" },
+                { type: "contains", text: "indexedDouble: number;" },
+            ],
+        },
     ];
     (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
 });

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

@@ -2,84 +2,84 @@
 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)('Enum Entity Template Tests', () => {
+(0, globals_1.describe)("Enum 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-enum';
+    const templatePath = "./entities/entity-col-enum";
     const testCases = [
         {
-            name: 'should render basic enum field correctly',
+            name: "should render basic enum field correctly",
             field: {
-                name: 'status',
-                dataType: 'enum',
+                name: "status",
+                dataType: "enum",
                 nullable: false,
                 // eslint-disable-next-line camelcase
-                enum_name: 'UserStatus',
+                enum_name: "UserStatus",
                 // eslint-disable-next-line camelcase
-                enum_values: ['ACTIVE', 'INACTIVE', 'PENDING']
+                enum_values: ["ACTIVE", "INACTIVE", "PENDING"],
             },
             assertions: [
-                { type: 'contains', text: "type: 'enum'" },
-                { type: 'contains', text: 'enum: enums.enum' },
-                { type: 'contains', text: 'status!: enums.enum;' },
-                { type: 'notContains', text: '@Index()' },
-                { type: 'notContains', text: '@PrimaryColumn()' }
-            ]
+                { type: "contains", text: "type: 'enum'" },
+                { type: "contains", text: "enum: enums.enum" },
+                { type: "contains", text: "status!: enums.enum;" },
+                { type: "notContains", text: "@Index()" },
+                { type: "notContains", text: "@PrimaryColumn()" },
+            ],
         },
         {
-            name: 'should render nullable enum field correctly',
+            name: "should render nullable enum field correctly",
             field: {
-                name: 'optionalStatus',
-                dataType: 'enum',
+                name: "optionalStatus",
+                dataType: "enum",
                 nullable: true,
                 // eslint-disable-next-line camelcase
-                enum_name: 'UserStatus',
+                enum_name: "UserStatus",
                 // eslint-disable-next-line camelcase
-                enum_values: ['ACTIVE', 'INACTIVE', 'PENDING']
+                enum_values: ["ACTIVE", "INACTIVE", "PENDING"],
             },
             assertions: [
-                { type: 'contains', text: "type: 'enum'" },
-                { type: 'contains', text: 'optionalStatus!: enums.enum;' }
-            ]
+                { type: "contains", text: "type: 'enum'" },
+                { type: "contains", text: "optionalStatus!: enums.enum;" },
+            ],
         },
         {
-            name: 'should render enum field with default value correctly',
+            name: "should render enum field with default value correctly",
             field: {
-                name: 'defaultStatus',
-                dataType: 'enum',
+                name: "defaultStatus",
+                dataType: "enum",
                 nullable: false,
                 // eslint-disable-next-line camelcase
-                enum_name: 'UserStatus',
+                enum_name: "UserStatus",
                 // eslint-disable-next-line camelcase
-                enum_values: ['ACTIVE', 'INACTIVE', 'PENDING'],
-                default: 'UserStatus.INACTIVE'
+                enum_values: ["ACTIVE", "INACTIVE", "PENDING"],
+                default: "UserStatus.INACTIVE",
             },
             assertions: [
-                { type: 'contains', text: "type: 'enum'" },
-                { type: 'contains', text: 'default: enums.enum.UserStatus.INACTIVE' },
-                { type: 'contains', text: 'defaultStatus!: enums.enum;' }
-            ]
+                { type: "contains", text: "type: 'enum'" },
+                { type: "contains", text: "default: enums.enum.UserStatus.INACTIVE" },
+                { type: "contains", text: "defaultStatus!: enums.enum;" },
+            ],
         },
         {
-            name: 'should render indexed enum field correctly',
+            name: "should render indexed enum field correctly",
             field: {
-                name: 'indexedStatus',
-                dataType: 'enum',
+                name: "indexedStatus",
+                dataType: "enum",
                 nullable: false,
                 // eslint-disable-next-line camelcase
-                enum_name: 'UserStatus',
+                enum_name: "UserStatus",
                 // eslint-disable-next-line camelcase
-                enum_values: ['ACTIVE', 'INACTIVE', 'PENDING'],
-                index: true
+                enum_values: ["ACTIVE", "INACTIVE", "PENDING"],
+                index: true,
             },
             assertions: [
-                { type: 'contains', text: "type: 'enum'" },
-                { type: 'contains', text: '@Index()' },
-                { type: 'contains', text: 'indexedStatus!: enums.enum;' }
-            ]
-        }
+                { type: "contains", text: "type: 'enum'" },
+                { type: "contains", text: "@Index()" },
+                { type: "contains", text: "indexedStatus!: enums.enum;" },
+            ],
+        },
     ];
     (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
 });