@apso/cli 0.7.4 → 0.8.3

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

@@ -1,402 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("@jest/globals");
-const parse_1 = require("./parse");
-(0, globals_1.describe)("parseRelationships", () => {
-    // Mock console.warn to prevent test output clutter
-    (0, globals_1.beforeEach)(() => {
-        globals_1.jest.spyOn(console, "warn").mockImplementation(() => {
-            /* No output */
-        });
-    });
-    (0, globals_1.afterEach)(() => {
-        globals_1.jest.restoreAllMocks();
-    });
-    (0, globals_1.describe)("ManyToMany Relationships", () => {
-        (0, globals_1.it)("should parse a single bidirectional ManyToMany definition", () => {
-            const relationships = [
-                {
-                    from: "EntityA",
-                    to: "EntityB",
-                    type: "ManyToMany",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true,
-                },
-            ];
-            const expected = {
-                EntityA: [
-                    {
-                        name: "EntityB",
-                        type: "ManyToMany",
-                        referenceName: "EntityB",
-                        join: true,
-                        biDirectional: true,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: "EntityA", // PascalCase entity name
-                    },
-                ],
-                EntityB: [
-                    {
-                        name: "EntityA",
-                        type: "ManyToMany",
-                        referenceName: "EntityA",
-                        join: false,
-                        biDirectional: true,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: "EntityB", // PascalCase entity name
-                    },
-                ],
-            };
-            const result = (0, parse_1.parseRelationships)(relationships);
-            (0, globals_1.expect)(result).toEqual(expected);
-        });
-        (0, globals_1.it)("should parse a single bidirectional ManyToMany with to_name", () => {
-            const relationships = [
-                {
-                    from: "User",
-                    to: "Group",
-                    type: "ManyToMany",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true,
-                    // eslint-disable-next-line camelcase
-                    to_name: "userGroups",
-                },
-            ];
-            const expected = {
-                User: [
-                    {
-                        name: "Group",
-                        type: "ManyToMany",
-                        referenceName: "userGroups",
-                        join: true,
-                        biDirectional: true,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: "User", // PascalCase entity name
-                    },
-                ],
-                Group: [
-                    {
-                        name: "User",
-                        type: "ManyToMany",
-                        referenceName: "User",
-                        join: false,
-                        biDirectional: true,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: "userGroups", // Preserved camelCase from to_name
-                    },
-                ],
-            };
-            const result = (0, parse_1.parseRelationships)(relationships);
-            (0, globals_1.expect)(result).toEqual(expected);
-        });
-        (0, globals_1.it)("should parse a unidirectional ManyToMany definition", () => {
-            const relationships = [
-                {
-                    from: "Post",
-                    to: "Tag",
-                    type: "ManyToMany",
-                    // bi_directional is false or omitted
-                },
-            ];
-            const expected = {
-                Post: [
-                    {
-                        name: "Tag",
-                        type: "ManyToMany",
-                        referenceName: "Tag",
-                        join: true,
-                        biDirectional: false,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: undefined, // Correct: No inverse name for unidirectional
-                    },
-                ],
-                // No entry expected for Tag
-            };
-            const result = (0, parse_1.parseRelationships)(relationships);
-            (0, globals_1.expect)(result).toEqual(expected);
-        });
-        (0, globals_1.it)("should handle join table details correctly", () => {
-            const relationships = [
-                {
-                    from: "Student",
-                    to: "Course",
-                    type: "ManyToMany",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true,
-                    // UNUSED: eslint-disable-next-line camelcase
-                    joinTableName: "enrollments",
-                    // UNUSED: eslint-disable-next-line camelcase
-                    joinColumnName: "student_id",
-                    // UNUSED: eslint-disable-next-line camelcase
-                    inverseJoinColumnName: "course_id",
-                },
-            ];
-            const expected = {
-                Student: [
-                    {
-                        name: "Course",
-                        type: "ManyToMany",
-                        referenceName: "Course",
-                        join: true,
-                        biDirectional: true,
-                        joinTableName: "enrollments",
-                        joinColumnName: "student_id",
-                        inverseJoinColumnName: "course_id",
-                        inverseReferenceName: "Student", // PascalCase entity name
-                    },
-                ],
-                Course: [
-                    {
-                        name: "Student",
-                        type: "ManyToMany",
-                        referenceName: "Student",
-                        join: false,
-                        biDirectional: true,
-                        joinTableName: undefined,
-                        joinColumnName: undefined,
-                        inverseJoinColumnName: undefined,
-                        inverseReferenceName: "Course", // PascalCase entity name
-                    },
-                ],
-            };
-            const result = (0, parse_1.parseRelationships)(relationships);
-            (0, globals_1.expect)(result).toEqual(expected);
-        });
-    });
-    (0, globals_1.describe)("Mixed Relationship Types", () => {
-        (0, globals_1.it)("should correctly parse ManyToMany alongside other types", () => {
-            const relationships = [
-                {
-                    from: "User",
-                    to: "Profile",
-                    type: "OneToOne",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true,
-                    // eslint-disable-next-line camelcase
-                    to_name: "userProfile",
-                },
-                {
-                    from: "User",
-                    to: "Post",
-                    type: "OneToMany",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true, // Implies ManyToOne on Post
-                },
-                {
-                    from: "Role",
-                    to: "User",
-                    type: "ManyToMany",
-                    // eslint-disable-next-line camelcase
-                    bi_directional: true,
-                },
-            ];
-            const result = (0, parse_1.parseRelationships)(relationships);
-            // Check User relationships
-            (0, globals_1.expect)(result.User).toHaveLength(3);
-            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({
-                name: "Profile",
-                type: "OneToOne",
-                referenceName: "userProfile",
-                biDirectional: true,
-                join: false,
-            })); // Expect preserved camelCase
-            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({
-                name: "Post",
-                type: "OneToMany",
-                referenceName: "Post",
-                biDirectional: true,
-            })); // PascalCase entity name
-            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({
-                name: "Role",
-                type: "ManyToMany",
-                referenceName: "Role",
-                biDirectional: true,
-                join: false,
-            })); // PascalCase entity name
-            // Check Profile relationship
-            (0, globals_1.expect)(result.Profile).toHaveLength(1);
-            (0, globals_1.expect)(result.Profile).toContainEqual(globals_1.expect.objectContaining({
-                name: "User",
-                type: "OneToOne",
-                referenceName: "User",
-                biDirectional: true,
-                join: true,
-            }));
-            // Check Post relationship
-            (0, globals_1.expect)(result.Post).toHaveLength(1);
-            (0, globals_1.expect)(result.Post).toContainEqual(globals_1.expect.objectContaining({
-                name: "User",
-                type: "ManyToOne",
-                referenceName: "User",
-                biDirectional: true,
-            }));
-            // Check Role relationship
-            (0, globals_1.expect)(result.Role).toHaveLength(1);
-            (0, globals_1.expect)(result.Role).toContainEqual(globals_1.expect.objectContaining({
-                name: "User",
-                type: "ManyToMany",
-                referenceName: "User",
-                biDirectional: true,
-                join: true,
-            })); // PascalCase entity name
-        });
-    });
-});
-(0, globals_1.describe)("getRelationshipForTemplate", () => {
-    // Mock console.warn to prevent test output clutter
-    (0, globals_1.beforeEach)(() => {
-        globals_1.jest.spyOn(console, "warn").mockImplementation(() => {
-            /* No output */
-        });
-    });
-    (0, globals_1.afterEach)(() => {
-        globals_1.jest.restoreAllMocks();
-    });
-    (0, globals_1.describe)("UUID Primary Key Support", () => {
-        (0, globals_1.it)("should populate referencedEntityPrimaryKeyType as uuid when referenced entity has uuid primary key", () => {
-            const entities = [
-                { name: "User", primaryKeyType: "uuid" },
-                { name: "Account", primaryKeyType: "serial" },
-            ];
-            const relationships = [
-                {
-                    name: "User",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: false,
-                },
-            ];
-            const result = (0, parse_1.getRelationshipForTemplate)("Account", relationships, entities);
-            (0, globals_1.expect)(result).toHaveLength(1);
-            (0, globals_1.expect)(result[0]).toMatchObject({
-                name: "User",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "uuid",
-            });
-        });
-        (0, globals_1.it)("should populate referencedEntityPrimaryKeyType as serial when referenced entity has serial primary key", () => {
-            const entities = [
-                { name: "User", primaryKeyType: "serial" },
-                { name: "Post", primaryKeyType: "serial" },
-            ];
-            const relationships = [
-                {
-                    name: "User",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: false,
-                },
-            ];
-            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
-            (0, globals_1.expect)(result).toHaveLength(1);
-            (0, globals_1.expect)(result[0]).toMatchObject({
-                name: "User",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "serial",
-            });
-        });
-        (0, globals_1.it)("should default referencedEntityPrimaryKeyType to serial when entity does not specify primaryKeyType", () => {
-            const entities = [
-                { name: "User" },
-                { name: "Post", primaryKeyType: "serial" },
-            ];
-            const relationships = [
-                {
-                    name: "User",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: false,
-                },
-            ];
-            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
-            (0, globals_1.expect)(result).toHaveLength(1);
-            (0, globals_1.expect)(result[0]).toMatchObject({
-                name: "User",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "serial",
-            });
-        });
-        (0, globals_1.it)("should default referencedEntityPrimaryKeyType to serial when entities array is not provided", () => {
-            const relationships = [
-                {
-                    name: "User",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: false,
-                },
-            ];
-            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships);
-            (0, globals_1.expect)(result).toHaveLength(1);
-            (0, globals_1.expect)(result[0]).toMatchObject({
-                name: "User",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "serial",
-            });
-        });
-        (0, globals_1.it)("should handle multiple relationships with mixed primary key types", () => {
-            const entities = [
-                { name: "User", primaryKeyType: "uuid" },
-                { name: "Organization", primaryKeyType: "serial" },
-                { name: "Team", primaryKeyType: "uuid" },
-                { name: "Post", primaryKeyType: "serial" },
-            ];
-            const relationships = [
-                {
-                    name: "User",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: true,
-                },
-                {
-                    name: "Organization",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: false,
-                    index: false,
-                },
-                {
-                    name: "Team",
-                    type: "ManyToOne",
-                    referenceName: null,
-                    nullable: true,
-                    index: false,
-                },
-            ];
-            const result = (0, parse_1.getRelationshipForTemplate)("Post", relationships, entities);
-            (0, globals_1.expect)(result).toHaveLength(3);
-            const userRel = result.find((r) => r.name === "User");
-            (0, globals_1.expect)(userRel).toMatchObject({
-                name: "User",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "uuid",
-            });
-            const orgRel = result.find((r) => r.name === "Organization");
-            (0, globals_1.expect)(orgRel).toMatchObject({
-                name: "Organization",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "serial",
-            });
-            const teamRel = result.find((r) => r.name === "Team");
-            (0, globals_1.expect)(teamRel).toMatchObject({
-                name: "Team",
-                type: "ManyToOne",
-                referencedEntityPrimaryKeyType: "uuid",
-            });
-        });
-    });
-});

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

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

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

@@ -1,82 +0,0 @@
-"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)("Array 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-array";
-    const testCases = [
-        {
-            name: "should render basic text array field correctly",
-            field: {
-                name: "tags",
-                dataType: "string[]",
-                nullable: false,
-            },
-            assertions: [
-                { type: "contains", text: "@Column({" },
-                { type: "contains", text: 'type: "text"' },
-                { type: "contains", text: "array: true" },
-                { type: "contains", text: "tags: string[];" },
-                { type: "notContains", text: "nullable: true" },
-            ],
-        },
-        {
-            name: "should render nullable array field correctly",
-            field: {
-                name: "optionalTags",
-                dataType: "string[]",
-                nullable: true,
-            },
-            assertions: [
-                { type: "contains", text: "nullable: true" },
-                { type: "contains", text: "optionalTags: string[];" },
-            ],
-        },
-        {
-            name: "should render indexed array field correctly",
-            field: {
-                name: "categories",
-                dataType: "string[]",
-                nullable: false,
-                index: true,
-            },
-            assertions: [
-                { type: "contains", text: "@Index()" },
-                { type: "contains", text: "categories: string[];" },
-            ],
-        },
-        {
-            name: "should render integer array field correctly",
-            field: {
-                name: "scores",
-                dataType: "number[]",
-                elementType: "int",
-                nullable: false,
-            },
-            assertions: [
-                { type: "contains", text: 'type: "int"' },
-                { type: "contains", text: "array: true" },
-                { type: "contains", text: "scores: number[];" },
-            ],
-        },
-        {
-            name: "should render decimal array field correctly",
-            field: {
-                name: "amounts",
-                dataType: "number[]",
-                elementType: "decimal",
-                nullable: false,
-            },
-            assertions: [
-                { type: "contains", text: 'type: "decimal"' },
-                { type: "contains", text: "array: true" },
-                { type: "contains", text: "amounts: number[];" },
-            ],
-        },
-    ];
-    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
-});

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

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

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

@@ -1,82 +0,0 @@
-"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)("BigInt 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-bigint";
-    const testCases = [
-        {
-            name: "should render basic bigint field correctly",
-            field: {
-                name: "largeCounter",
-                dataType: "number",
-                nullable: false,
-            },
-            assertions: [
-                { type: "contains", text: '@Column({ "type": "bigint"' },
-                { type: "contains", text: "largeCounter: string;" },
-                { type: "notContains", text: "@Index()" },
-                { type: "notContains", text: "@PrimaryColumn()" },
-            ],
-        },
-        {
-            name: "should render nullable bigint field correctly",
-            field: {
-                name: "optionalCounter",
-                dataType: "number",
-                nullable: true,
-            },
-            assertions: [
-                { type: "contains", text: '@Column({ "type": "bigint"' },
-                { type: "contains", text: "optionalCounter: string;" },
-            ],
-        },
-        {
-            name: "should render bigint field with default value correctly",
-            field: {
-                name: "defaultCounter",
-                dataType: "number",
-                nullable: false,
-                default: 0,
-            },
-            assertions: [
-                { type: "contains", text: '@Column({ "type": "bigint"' },
-                { type: "contains", text: "default:  0" },
-                { type: "contains", text: "defaultCounter: string;" },
-            ],
-        },
-        {
-            name: "should render indexed bigint field correctly",
-            field: {
-                name: "indexedCounter",
-                dataType: "number",
-                nullable: false,
-                index: true,
-            },
-            assertions: [
-                { type: "contains", text: '@Column({ "type": "bigint"' },
-                { type: "contains", text: "@Index()" },
-                { type: "contains", text: "indexedCounter: string;" },
-            ],
-        },
-        {
-            name: "should render primary key bigint field correctly",
-            field: {
-                name: "id",
-                dataType: "number",
-                nullable: false,
-                primary: true,
-            },
-            assertions: [
-                { type: "contains", text: '@Column({ "type": "bigint"' },
-                { type: "contains", text: "@PrimaryColumn()" },
-                { type: "contains", text: "id: string;" },
-            ],
-        },
-    ];
-    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
-});

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

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

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

@@ -1,77 +0,0 @@
-"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)("Boolean 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-boolean";
-    const testCases = [
-        {
-            name: "should render basic boolean field correctly",
-            field: {
-                name: "isActive",
-                dataType: "boolean",
-                nullable: false,
-            },
-            assertions: [
-                { type: "contains", text: "@IsOptional({ groups: [CREATE, UPDATE] })" },
-                { type: "contains", text: "@IsBoolean({ always: true })" },
-                { type: "contains", text: "@Column({ type: 'boolean'" },
-                { type: "contains", text: "default: false" },
-                { type: "contains", text: "isActive!: boolean;" },
-                { type: "notContains", text: "@Index()" },
-                { type: "notContains", text: "@PrimaryColumn()" },
-            ],
-        },
-        {
-            name: "should render nullable boolean field correctly",
-            field: {
-                name: "optionalFlag",
-                dataType: "boolean",
-                nullable: true,
-            },
-            assertions: [
-                { type: "contains", text: "@IsOptional({ groups: [CREATE, UPDATE] })" },
-                { type: "contains", text: "@IsBoolean({ always: true })" },
-                { type: "contains", text: "@Column({ type: 'boolean'" },
-                { type: "contains", text: "optionalFlag!: boolean;" },
-            ],
-        },
-        {
-            name: "should render boolean field with default value correctly",
-            field: {
-                name: "defaultFlag",
-                dataType: "boolean",
-                nullable: false,
-                default: "true",
-            },
-            assertions: [
-                { type: "contains", text: "@IsOptional({ groups: [CREATE, UPDATE] })" },
-                { type: "contains", text: "@IsBoolean({ always: true })" },
-                { type: "contains", text: "@Column({ type: 'boolean'" },
-                { type: "contains", text: "default: true" },
-                { type: "contains", text: "defaultFlag!: boolean;" },
-            ],
-        },
-        {
-            name: "should render indexed boolean field correctly",
-            field: {
-                name: "indexedFlag",
-                dataType: "boolean",
-                nullable: false,
-                index: true,
-            },
-            assertions: [
-                { type: "contains", text: "@IsOptional({ groups: [CREATE, UPDATE] })" },
-                { type: "contains", text: "@IsBoolean({ always: true })" },
-                { type: "contains", text: "@Column({ type: 'boolean'" },
-                { type: "contains", text: "@Index()" },
-                { type: "contains", text: "indexedFlag!: boolean;" },
-            ],
-        },
-    ];
-    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
-});

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

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