@uql/core 0.4.80 → 0.4.83

package/repository/genericRepository.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@uql/core/test");
+const genericRepository_1 = require("./genericRepository");
+describe('repository', () => {
+    let repository;
+    let querier;
+    beforeEach(() => {
+        querier = {
+            count: jest.fn(),
+            findOneById: jest.fn(),
+            findOne: jest.fn(),
+            findMany: jest.fn(),
+            findManyAndCount: jest.fn(),
+            insertOne: jest.fn(),
+            insertMany: jest.fn(),
+            updateOneById: jest.fn(),
+            updateMany: jest.fn(),
+            saveOne: jest.fn(),
+            saveMany: jest.fn(),
+            deleteOneById: jest.fn(),
+            deleteMany: jest.fn(),
+        };
+        repository = new genericRepository_1.GenericRepository(test_1.User, querier);
+    });
+    it('count', async () => {
+        await repository.count({});
+        expect(querier.count).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('findOneById', async () => {
+        await repository.findOneById(1);
+        expect(querier.findOneById).toHaveBeenCalledWith(test_1.User, 1, undefined);
+    });
+    it('findOne', async () => {
+        await repository.findOne({});
+        expect(querier.findOne).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('findMany', async () => {
+        await repository.findMany({});
+        expect(querier.findMany).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('findManyAndCount', async () => {
+        await repository.findManyAndCount({});
+        expect(querier.findManyAndCount).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('insertOne', async () => {
+        await repository.insertOne({});
+        expect(querier.insertOne).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('insertMany', async () => {
+        await repository.insertMany([{}]);
+        expect(querier.insertMany).toHaveBeenCalledWith(test_1.User, [{}]);
+    });
+    it('updateMany', async () => {
+        await repository.updateMany({}, {});
+        expect(querier.updateMany).toHaveBeenCalledWith(test_1.User, {}, {});
+    });
+    it('updateOneById', async () => {
+        await repository.updateOneById(1, {});
+        expect(querier.updateOneById).toHaveBeenCalledWith(test_1.User, 1, {});
+    });
+    it('saveOne', async () => {
+        await repository.saveOne({});
+        expect(querier.saveOne).toHaveBeenCalledWith(test_1.User, {});
+    });
+    it('insertMany', async () => {
+        await repository.saveMany([{}]);
+        expect(querier.saveMany).toHaveBeenCalledWith(test_1.User, [{}]);
+    });
+    it('deleteOneById', async () => {
+        await repository.deleteOneById(1);
+        expect(querier.deleteOneById).toHaveBeenCalledWith(test_1.User, 1, undefined);
+        await repository.deleteOneById(1, { softDelete: false });
+        expect(querier.deleteOneById).toHaveBeenCalledWith(test_1.User, 1, { softDelete: false });
+    });
+    it('deleteMany', async () => {
+        await repository.deleteMany({});
+        expect(querier.deleteMany).toHaveBeenCalledWith(test_1.User, {}, undefined);
+        await repository.deleteMany({}, { softDelete: false });
+        expect(querier.deleteMany).toHaveBeenCalledWith(test_1.User, {}, { softDelete: false });
+    });
+    it('repository property', () => {
+        expect(repository.querier).toBe(querier);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"genericRepository.spec.js","sourceRoot":"","sources":["../../src/repository/genericRepository.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { User } from '@uql/core/test';\nimport { Querier, Repository } from '@uql/core/type';\nimport { GenericRepository } from './genericRepository';\n\ndescribe('repository', () => {\n  let repository: Repository<User>;\n  let querier: Partial<Querier>;\n\n  beforeEach(() => {\n    querier = {\n      count: jest.fn(),\n      findOneById: jest.fn(),\n      findOne: jest.fn(),\n      findMany: jest.fn(),\n      findManyAndCount: jest.fn(),\n      insertOne: jest.fn(),\n      insertMany: jest.fn(),\n      updateOneById: jest.fn(),\n      updateMany: jest.fn(),\n      saveOne: jest.fn(),\n      saveMany: jest.fn(),\n      deleteOneById: jest.fn(),\n      deleteMany: jest.fn(),\n    };\n    repository = new GenericRepository(User, querier as Querier);\n  });\n\n  it('count', async () => {\n    await repository.count({});\n    expect(querier.count).toHaveBeenCalledWith(User, {});\n  });\n\n  it('findOneById', async () => {\n    await repository.findOneById(1);\n    expect(querier.findOneById).toHaveBeenCalledWith(User, 1, undefined);\n  });\n\n  it('findOne', async () => {\n    await repository.findOne({});\n    expect(querier.findOne).toHaveBeenCalledWith(User, {});\n  });\n\n  it('findMany', async () => {\n    await repository.findMany({});\n    expect(querier.findMany).toHaveBeenCalledWith(User, {});\n  });\n\n  it('findManyAndCount', async () => {\n    await repository.findManyAndCount({});\n    expect(querier.findManyAndCount).toHaveBeenCalledWith(User, {});\n  });\n\n  it('insertOne', async () => {\n    await repository.insertOne({});\n    expect(querier.insertOne).toHaveBeenCalledWith(User, {});\n  });\n\n  it('insertMany', async () => {\n    await repository.insertMany([{}]);\n    expect(querier.insertMany).toHaveBeenCalledWith(User, [{}]);\n  });\n\n  it('updateMany', async () => {\n    await repository.updateMany({}, {});\n    expect(querier.updateMany).toHaveBeenCalledWith(User, {}, {});\n  });\n\n  it('updateOneById', async () => {\n    await repository.updateOneById(1, {});\n    expect(querier.updateOneById).toHaveBeenCalledWith(User, 1, {});\n  });\n\n  it('saveOne', async () => {\n    await repository.saveOne({});\n    expect(querier.saveOne).toHaveBeenCalledWith(User, {});\n  });\n\n  it('insertMany', async () => {\n    await repository.saveMany([{}]);\n    expect(querier.saveMany).toHaveBeenCalledWith(User, [{}]);\n  });\n\n  it('deleteOneById', async () => {\n    await repository.deleteOneById(1);\n    expect(querier.deleteOneById).toHaveBeenCalledWith(User, 1, undefined);\n\n    await repository.deleteOneById(1, { softDelete: false });\n    expect(querier.deleteOneById).toHaveBeenCalledWith(User, 1, { softDelete: false });\n  });\n\n  it('deleteMany', async () => {\n    await repository.deleteMany({});\n    expect(querier.deleteMany).toHaveBeenCalledWith(User, {}, undefined);\n\n    await repository.deleteMany({}, { softDelete: false });\n    expect(querier.deleteMany).toHaveBeenCalledWith(User, {}, { softDelete: false });\n  });\n\n  it('repository property', () => {\n    expect(repository.querier).toBe(querier);\n  });\n});\n"]}

package/test/entityMock.d.ts

@@ -0,0 +1,180 @@
+import { idKey } from '@uql/core/type';
+/**
+ * interfaces can (optionally) be used to avoid circular-reference issue between entities.
+ */
+export interface IEntity {
+    id?: number;
+    companyId?: number;
+    company?: ICompany;
+    creatorId?: number;
+    creator?: IUser;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface ICompany extends IEntity {
+    name?: string;
+    description?: string;
+}
+interface IUser extends IEntity {
+    name?: string;
+    email?: string;
+    password?: string;
+    profile?: Profile;
+}
+/**
+ * an abstract class can (optionally) be used as a "template" for the entities
+ * (so the common attributes' declaration is reused).
+ */
+export declare abstract class BaseEntity implements IEntity {
+    id?: number;
+    /**
+     * foreign-keys are really simple to specify
+     */
+    companyId?: number;
+    company?: ICompany;
+    creatorId?: number;
+    creator?: IUser;
+    /**
+     * 'onInsert' callback can be used to specify a custom mechanism for
+     * obtaining the value of a field when inserting:
+     */
+    createdAt?: number;
+    /**
+     * 'onUpdate' callback can be used to specify a custom mechanism for
+     * obtaining the value of a field when updating:
+     */
+    updatedAt?: number;
+}
+/**
+ * `Company` will inherit all the fields (including the `Id`) declared in `BaseEntity`.
+ */
+export declare class Company extends BaseEntity implements ICompany {
+    name?: string;
+    description?: string;
+}
+/**
+ * and entity can specify the table name
+ */
+export declare class Profile extends BaseEntity {
+    /**
+     * an entity can specify its own ID Field and still inherit the others
+     * columns/relations from its parent entity.
+     * 'onInsert' callback can be used to specify a custom mechanism for
+     * auto-generating the primary-key's value when inserting.
+     */
+    id?: number;
+    picture?: string;
+    creator?: IUser;
+}
+export declare class User extends BaseEntity implements IUser {
+    name?: string;
+    email?: string;
+    password?: string;
+    /**
+     * `mappedBy` can be a callback or a string (callback is useful for auto-refactoring).
+     */
+    profile?: Profile;
+    users?: User[];
+}
+export declare class LedgerAccount extends BaseEntity {
+    name?: string;
+    description?: string;
+    parentLedgerId?: number;
+    parentLedger?: LedgerAccount;
+}
+export declare class TaxCategory extends BaseEntity {
+    /**
+     * `idKey` symbol can be used to specify the name of the identifier property,
+     * so the type of the identifier can always be type-safe
+     * (the identifiers named as `id` or `_id` are auto-inferred).
+     */
+    [idKey]?: 'pk';
+    /**
+     * an entity can specify its own ID Field and still inherit the others
+     * columns/relations from its parent entity.
+     * 'onInsert' callback can be used to specify a custom mechanism for
+     * auto-generating the primary-key's value when inserting.
+     */
+    pk?: string;
+    name?: string;
+    description?: string;
+}
+export declare class Test {
+    name?: string;
+    percentage?: number;
+    categoryId?: string;
+    category?: TaxCategory;
+    description?: string;
+}
+export declare class Tax extends BaseEntity {
+    name?: string;
+    percentage?: number;
+    categoryId?: string;
+    category?: TaxCategory;
+    description?: string;
+}
+/**
+ * `softDelete` will make the entity "soft deletable".
+ */
+export declare class MeasureUnitCategory extends BaseEntity {
+    name?: string;
+    measureUnits?: MeasureUnit[];
+    /**
+     * `onDelete` callback allows to specify which field will be used when deleting/querying this entity.
+     */
+    deletedAt?: number;
+}
+export declare class MeasureUnit extends BaseEntity {
+    name?: string;
+    categoryId?: number;
+    category?: MeasureUnitCategory;
+    deletedAt?: number;
+}
+export declare class Storehouse extends BaseEntity {
+    name?: string;
+    address?: string;
+    description?: string;
+}
+export declare class Item extends BaseEntity {
+    name?: string;
+    description?: string;
+    code?: string;
+    buyLedgerAccountId?: number;
+    buyLedgerAccount?: LedgerAccount;
+    saleLedgerAccountId?: number;
+    saleLedgerAccount?: LedgerAccount;
+    taxId?: number;
+    tax?: Tax;
+    measureUnitId?: number;
+    measureUnit?: MeasureUnit;
+    salePrice?: number;
+    inventoryable?: boolean;
+    tags?: Tag[];
+    tagsCount?: number;
+}
+export declare class Tag extends BaseEntity {
+    name?: string;
+    items?: Item[];
+    itemsCount?: number;
+}
+export declare class ItemTag {
+    id?: number;
+    itemId?: number;
+    tagId?: number;
+}
+export declare class InventoryAdjustment extends BaseEntity {
+    itemAdjustments?: ItemAdjustment[];
+    date?: Date;
+    description?: string;
+}
+export declare class ItemAdjustment extends BaseEntity {
+    itemId?: number;
+    item?: Item;
+    number?: number;
+    buyPrice?: number;
+    storehouseId?: number;
+    storehouse?: Storehouse;
+    inventoryAdjustmentId?: number;
+    inventoryAdjustment?: InventoryAdjustment;
+}
+export {};