@apso/cli 0.0.5 → 0.0.43

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseV1Relationships = exports.getRelationshipIdField = exports.getNestedRelationships = exports.getRelationshipForTemplate = exports.getRelationshipsForImport = exports.parseRelationships = void 0;
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "parseRelationships", { enumerable: true, get: function () { return parse_1.parseRelationships; } });
+Object.defineProperty(exports, "getRelationshipsForImport", { enumerable: true, get: function () { return parse_1.getRelationshipsForImport; } });
+Object.defineProperty(exports, "getRelationshipForTemplate", { enumerable: true, get: function () { return parse_1.getRelationshipForTemplate; } });
+Object.defineProperty(exports, "getNestedRelationships", { enumerable: true, get: function () { return parse_1.getNestedRelationships; } });
+Object.defineProperty(exports, "getRelationshipIdField", { enumerable: true, get: function () { return parse_1.getRelationshipIdField; } });
+var parse_v1_1 = require("./parse-v1");
+Object.defineProperty(exports, "parseV1Relationships", { enumerable: true, get: function () { return parse_v1_1.parseV1Relationships; } });

package/dist/lib/utils/relationships/parse-v1.d.ts

@@ -0,0 +1,4 @@
+import { Association, Entity, RelationshipMap } from "../../types";
+export declare const isInverseRelationshipDefined: (entityName: string, association: Association, entities: Entity[]) => boolean;
+export declare const getInverseRelationship: (entityName: string, association: Association, entities: Entity[]) => Association | null;
+export declare const parseV1Relationships: (entities: Entity[]) => RelationshipMap;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseV1Relationships = exports.getInverseRelationship = exports.isInverseRelationshipDefined = void 0;
+const parse_1 = require("./parse");
+const InverseType = {
+    OneToOne: "OneToOne",
+    OneToMany: "ManyToOne",
+    ManyToOne: "OneToMany",
+    ManyToMany: "ManyToMany",
+};
+const isInverseRelationshipDefined = (entityName, association, entities) => {
+    if (entityName === association.name) {
+        return false;
+    }
+    return Boolean((0, exports.getInverseRelationship)(entityName, association, entities));
+};
+exports.isInverseRelationshipDefined = isInverseRelationshipDefined;
+const getInverseRelationship = (entityName, association, entities) => {
+    var _a, _b;
+    if (entityName === association.name) {
+        return null;
+    }
+    const inverseAssociationType = InverseType[association.type];
+    const isInverse = (testAssocation) => testAssocation.name === entityName &&
+        testAssocation.type === inverseAssociationType;
+    return (((_b = (_a = entities
+        .find((entity) => entity.name === association.name)) === null || _a === void 0 ? void 0 : _a.associations) === null || _b === void 0 ? void 0 : _b.find(isInverse)) || null);
+};
+exports.getInverseRelationship = getInverseRelationship;
+const convertAssociationToRelationship = (entityName, association, entities) => {
+    const inverseRelation = (0, exports.getInverseRelationship)(entityName, association, entities);
+    let biDirectional = Boolean(inverseRelation);
+    let index = association.index;
+    if (association.type === "OneToMany" && inverseRelation) {
+        index = inverseRelation.index || false;
+    }
+    if (association.type === "ManyToOne" && biDirectional) {
+        return null;
+    }
+    if (association.type === "ManyToMany" && inverseRelation) {
+        if (association.join_table !== true &&
+            inverseRelation.join_table === true) {
+            return null;
+        }
+        if (association.join_table === true &&
+            inverseRelation.join_table === true) {
+            // Both ManyToMany sides have join_table set to true
+            biDirectional = false;
+        }
+    }
+    const inverseNullable = (inverseRelation && inverseRelation.nullable) || false;
+    return {
+        from: entityName,
+        to: association.name,
+        type: association.type,
+        /* eslint-disable-next-line  camelcase */
+        to_name: association.reference_name,
+        nullable: association.nullable || inverseNullable,
+        /* eslint-disable-next-line  camelcase */
+        bi_directional: biDirectional,
+        index,
+    };
+};
+const parseV1Relationships = (entities) => {
+    const relationshipMap = {};
+    for (const entity of entities) {
+        if (!entity.associations) {
+            continue;
+        }
+        for (const association of entity.associations) {
+            const apsorcRelationship = convertAssociationToRelationship(entity.name, association, entities);
+            if (apsorcRelationship === null) {
+                continue;
+            }
+            const parsedResult = (0, parse_1.parseRelationship)(apsorcRelationship);
+            for (const key of Object.keys(parsedResult)) {
+                relationshipMap[key] = [
+                    ...(relationshipMap[key] || []),
+                    ...parsedResult[key],
+                ];
+            }
+        }
+    }
+    return relationshipMap;
+};
+exports.parseV1Relationships = parseV1Relationships;

package/dist/lib/utils/relationships/parse.d.ts

@@ -0,0 +1,11 @@
+import { ApsorcRelationship, Relationship, RelationshipMap, RelationshipForTemplate } from "../../types";
+export declare const parseOneToMany: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseManytoOne: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseManyToMany: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseOneToOne: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseRelationship: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseRelationships: (relationships: ApsorcRelationship[]) => RelationshipMap;
+export declare const getRelationshipIdField: (relationship: Relationship) => string;
+export declare const getRelationshipForTemplate: (entityName: string, relationships: Relationship[]) => RelationshipForTemplate[];
+export declare const getNestedRelationships: (entityName: string, relationshipMap: RelationshipMap, prefix?: string, visited?: Set<string>) => string[];
+export declare const getRelationshipsForImport: (entityName: string, relationships?: Relationship[]) => string[];

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelationshipsForImport = exports.getNestedRelationships = exports.getRelationshipForTemplate = exports.getRelationshipIdField = exports.parseRelationships = exports.parseRelationship = exports.parseOneToOne = 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 parseOneToMany = (relationship) => {
+    return {
+        [relationship.from]: [
+            {
+                name: relationship.to,
+                type: "OneToMany",
+                biDirectional: true
+            },
+        ],
+        [relationship.to]: [
+            {
+                name: relationship.from,
+                type: "ManyToOne",
+                nullable: relationship.nullable || false,
+                biDirectional: true,
+                index: relationship.index || false,
+                cascadeDelete: relationship.cascadeDelete || false
+            },
+        ],
+    };
+};
+exports.parseOneToMany = parseOneToMany;
+const parseManytoOne = (relationship) => {
+    return {
+        [relationship.from]: [
+            {
+                name: relationship.to,
+                type: "ManyToOne",
+                referenceName: relationship.to_name || null,
+                nullable: relationship.nullable || false,
+                index: relationship.index || false,
+            },
+        ],
+    };
+};
+exports.parseManytoOne = parseManytoOne;
+const parseManyToMany = (relationship) => {
+    const response = {
+        [relationship.from]: [
+            {
+                name: relationship.to,
+                type: "ManyToMany",
+                referenceName: relationship.to_name || null,
+                join: true,
+                biDirectional: relationship.bi_directional || false,
+            },
+        ],
+    };
+    if (relationship.bi_directional) {
+        response[relationship.to] = [
+            {
+                name: relationship.from,
+                type: "ManyToMany",
+                biDirectional: true,
+            },
+        ];
+    }
+    return response;
+};
+exports.parseManyToMany = parseManyToMany;
+const parseOneToOne = (relationship) => {
+    const response = {
+        [relationship.from]: [
+            {
+                name: relationship.to,
+                type: "OneToOne",
+                join: true,
+                nullable: relationship.nullable || false,
+                referenceName: relationship.to_name || null,
+                biDirectional: relationship.bi_directional || false,
+            },
+        ],
+    };
+    if (relationship.bi_directional) {
+        response[relationship.to] = [
+            {
+                name: relationship.from,
+                type: "OneToOne",
+                biDirectional: true,
+            },
+        ];
+    }
+    return response;
+};
+exports.parseOneToOne = parseOneToOne;
+const parseRelationship = (relationship) => {
+    switch (relationship.type) {
+        case "OneToMany":
+            return (0, exports.parseOneToMany)(relationship);
+        case "ManyToOne":
+            return (0, exports.parseManytoOne)(relationship);
+        case "ManyToMany":
+            return (0, exports.parseManyToMany)(relationship);
+        case "OneToOne":
+            return (0, exports.parseOneToOne)(relationship);
+    }
+    return {};
+};
+exports.parseRelationship = parseRelationship;
+const parseRelationships = (relationships) => {
+    const response = {};
+    for (const rel of relationships) {
+        const parsedResult = (0, exports.parseRelationship)(rel);
+        for (const key of Object.keys(parsedResult)) {
+            response[key] = [...(response[key] || []), ...parsedResult[key]];
+        }
+    }
+    return response;
+};
+exports.parseRelationships = parseRelationships;
+const getRelationshipName = (relationship) => {
+    if (relationship.referenceName) {
+        return (0, casing_1.camelCase)(relationship.referenceName);
+    }
+    return (0, casing_1.camelCase)(relationship.name);
+};
+const getRelationshipIdField = (relationship) => {
+    return `${getRelationshipName(relationship)}Id`;
+};
+exports.getRelationshipIdField = getRelationshipIdField;
+const getRelationshipForTemplate = (entityName, relationships) => {
+    if (!relationships) {
+        return [];
+    }
+    return relationships.map((relationship) => {
+        const relationshipName = getRelationshipName(relationship);
+        return {
+            ...relationship,
+            relationshipName,
+            pluralizedRelationshipName: (0, pluralize_1.default)(relationshipName),
+            pluralizedName: (0, pluralize_1.default)((0, casing_1.camelCase)(relationship.name)),
+            camelCasedName: (0, casing_1.camelCase)(relationship.name),
+            camelCasedId: (0, exports.getRelationshipIdField)(relationship),
+            entityName: (0, casing_1.camelCase)(entityName),
+            joinTable: relationship.join || false,
+            biDirectional: relationship.biDirectional || false,
+            cascadeDelete: relationship.cascadeDelete || false,
+        };
+    });
+};
+exports.getRelationshipForTemplate = getRelationshipForTemplate;
+const getNestedRelationships = (entityName, relationshipMap, prefix = "", visited = new Set()) => {
+    const relationships = [];
+    if (visited.has(entityName)) {
+        return relationships;
+    }
+    const currentRelationships = relationshipMap[entityName];
+    if (!currentRelationships)
+        return relationships;
+    visited.add(entityName);
+    for (const relationship of currentRelationships) {
+        const { name: relationshipName, type } = relationship;
+        const referenceName = getRelationshipName(relationship);
+        const formattedName = type === "ManyToOne" || type === "OneToOne"
+            ? (0, casing_1.camelCase)(referenceName)
+            : (0, pluralize_1.default)((0, casing_1.camelCase)(referenceName));
+        const relationshipPath = prefix
+            ? `${prefix}.${formattedName}`
+            : formattedName;
+        const hasChild = relationshipPath.includes(".");
+        const exists = prefix
+            .split(".")
+            .some((a) => a === (0, casing_1.camelCase)(referenceName) ||
+            a === (0, pluralize_1.default)((0, casing_1.camelCase)(referenceName)));
+        const deepEnough = prefix.split(".").length >= 4;
+        const canAdd = hasChild && !exists && !deepEnough;
+        if (canAdd) {
+            relationships.push(relationshipPath);
+        }
+        const nestedRelationships = (0, exports.getNestedRelationships)(relationshipName, relationshipMap, relationshipPath, new Set(visited));
+        relationships.push(...nestedRelationships);
+    }
+    return relationships;
+};
+exports.getNestedRelationships = getNestedRelationships;
+const getRelationshipsForImport = (entityName, relationships) => {
+    if (relationships === undefined) {
+        return [];
+    }
+    return [
+        ...new Set(relationships
+            .map((relationship) => relationship.name)
+            .filter((relationshipName) => relationshipName !== entityName)),
+    ];
+};
+exports.getRelationshipsForImport = getRelationshipsForImport;

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

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

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

@@ -0,0 +1,82 @@
+"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

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

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

@@ -0,0 +1,82 @@
+"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

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

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

@@ -0,0 +1,77 @@
+"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

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

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

@@ -0,0 +1,68 @@
+"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)('Bytea 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-bytea';
+    const testCases = [
+        {
+            name: 'should render basic bytea field correctly',
+            field: {
+                name: 'binaryData',
+                dataType: 'Buffer',
+                nullable: false
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({ "type": "bytea"' },
+                { type: 'contains', text: 'binaryData: Buffer;' },
+                { type: 'notContains', text: '@Index()' },
+                { type: 'notContains', text: '@PrimaryColumn()' }
+            ]
+        },
+        {
+            name: 'should render nullable bytea field correctly',
+            field: {
+                name: 'optionalData',
+                dataType: 'Buffer',
+                nullable: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({ "type": "bytea"' },
+                { type: 'contains', text: 'optionalData: Buffer;' }
+            ]
+        },
+        {
+            name: 'should render indexed bytea field correctly',
+            field: {
+                name: 'indexedData',
+                dataType: 'Buffer',
+                nullable: false,
+                index: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({ "type": "bytea"' },
+                { type: 'contains', text: '@Index()' },
+                { type: 'contains', text: 'indexedData: Buffer;' }
+            ]
+        },
+        {
+            name: 'should render primary key bytea field correctly',
+            field: {
+                name: 'id',
+                dataType: 'Buffer',
+                nullable: false,
+                primary: true
+            },
+            assertions: [
+                { type: 'contains', text: '@Column({ "type": "bytea"' },
+                { type: 'contains', text: '@PrimaryColumn()' },
+                { type: 'contains', text: 'id: Buffer;' }
+            ]
+        }
+    ];
+    (0, template_test_utils_1.runTemplateTests)(templatePath, testCases);
+});

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

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