kysely-mapper/dist/esm/tests/sample-mappers.test.js

Flexible Kysely-based utility for mapping between tables and objects

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { USERS, insertedUser1 } from './utils/test-objects';
import { TableMapper } from '../mappers/table-mapper';
import { EntireRowTransforms } from '../mappers/entire-row-transforms';
let db;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
    db = yield createDB();
}));
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('mappers that input and output the same type of object', () => {
    it('inserts/updates/deletes with default transforms', () => __awaiter(void 0, void 0, void 0, function* () {
        class MappedUser {
            constructor(id, name, handle, email) {
                this.id = id;
                this.name = name;
                this.handle = handle;
                this.email = email;
            }
        }
        const keyColumns = ['id'];
        const userMapper = new TableMapper(db, 'users', {
            keyColumns,
            updateReturnColumns: ['id', 'name'],
        }).withTransforms(new EntireRowTransforms(keyColumns));
        // test updating a non-existent user
        const userWithID = new MappedUser(1, USERS[0].name, USERS[0].handle, USERS[0].email);
        const updateReturn1 = yield userMapper
            .update({ id: 1 })
            .returnOne(userWithID);
        expect(updateReturn1).toEqual(null);
        // test inserting a user with falsy id
        const insertedUser1 = new MappedUser(0, USERS[0].name, USERS[0].handle, USERS[0].email);
        const insertReturn1 = (yield userMapper.insert().returnOne(insertedUser1));
        expect(insertReturn1).not.toBeNull();
        expect(insertReturn1.id).toBeGreaterThan(0);
        insertReturn1.name; // ensure 'name' is accessible
        // test getting a user by ID
        const selectedUser1 = yield userMapper
            .select({ id: insertReturn1.id })
            .returnOne();
        expect(selectedUser1).toEqual(Object.assign(Object.assign({}, insertedUser1), { id: insertReturn1.id }));
        // ensure 'id' is accessible
        expect(selectedUser1 === null || selectedUser1 === void 0 ? void 0 : selectedUser1.id).toEqual(insertReturn1.id);
        selectedUser1 === null || selectedUser1 === void 0 ? void 0 : selectedUser1.name; // ensure 'name' is accessible
        // test inserting a user with truthy id
        const insertedUser2 = new MappedUser(10, USERS[1].name, USERS[1].handle, USERS[1].email);
        const insertReturn2 = (yield userMapper.insert().returnOne(insertedUser2));
        expect(insertReturn2).toEqual(insertedUser2);
        insertReturn2 === null || insertReturn2 === void 0 ? void 0 : insertReturn2.name; // ensure 'name' is accessible
        const selectedUser2 = yield userMapper
            .select({ id: insertReturn2.id })
            .returnOne();
        expect(selectedUser2).toEqual(insertedUser2);
        // test updating a user, with returned row
        const updatingUser = new MappedUser(selectedUser1.id, 'Xana', selectedUser1.handle, selectedUser1.email);
        const updateReturn = yield userMapper
            .update({ id: updatingUser.id })
            .returnOne(updatingUser);
        updateReturn === null || updateReturn === void 0 ? void 0 : updateReturn.id; // ensure 'id' is accessible
        updateReturn === null || updateReturn === void 0 ? void 0 : updateReturn.name; // ensure 'name' is accessible
        expect(updateReturn).toEqual(updatingUser);
        const selectedUser3 = yield userMapper
            .select({ id: insertReturn1.id })
            .returnOne();
        expect(selectedUser3).toEqual(updatingUser);
        // test updating a user, without returned row
        const updatingUser2 = new MappedUser(selectedUser3.id, 'Freddy', selectedUser3.handle, selectedUser3.email);
        const updateReturn2 = yield userMapper
            .update({ id: updatingUser2.id })
            .run(updatingUser2);
        expect(updateReturn2).toBe(true);
        const selectedUser4 = yield userMapper
            .select({ id: insertReturn1.id })
            .returnOne();
        expect(selectedUser4).toEqual(updatingUser2);
        // test updating multiple users returning rows
        const updatingUser3 = new MappedUser(selectedUser1.id, 'Everyone', selectedUser1.handle, selectedUser1.email);
        const updateReturn3 = yield userMapper
            .update()
            .columns(['name', 'handle', 'email'])
            .returnAll(updatingUser3);
        expect(updateReturn3).toEqual([
            Object.assign(Object.assign({}, updatingUser3), { id: 1 }),
            Object.assign(Object.assign({}, updatingUser3), { id: 10 }),
        ]);
        updateReturn3[0].id; // ensure 'id' is accessible
        updateReturn3[0].name; // ensure 'name' is accessible
        // test deleting a user
        const deleted = yield userMapper.delete({ id: insertReturn1.id }).run();
        expect(deleted).toEqual(true);
        const selectedUser5 = yield userMapper
            .select({ id: insertReturn1.id })
            .returnOne();
        expect(selectedUser5).toBeNull();
    }));
    it('inserts/updates/deletes with all custom transforms', () => __awaiter(void 0, void 0, void 0, function* () {
        class MappedUser {
            constructor(serialNo, firstName, lastName, handle, email) {
                this.serialNo = serialNo;
                this.firstName = firstName;
                this.lastName = lastName;
                this.handle = handle;
                this.email = email;
            }
        }
        const userMapper = new TableMapper(db, 'users', {
            keyColumns: ['id'],
            updateReturnColumns: ['id'],
        }).withTransforms({
            insertTransform: (user) => ({
                name: `${user.firstName} ${user.lastName}`,
                handle: user.handle,
                email: user.email,
            }),
            insertReturnTransform: (user, returns) => new MappedUser(returns.id, user.firstName, user.lastName, user.handle, user.email),
            updateTransform: (user) => {
                if (!(user instanceof MappedUser)) {
                    return user;
                }
                return {
                    name: `${user.firstName} ${user.lastName}`,
                    handle: user.handle + '2',
                    email: user.email,
                };
            },
            updateReturnTransform: (user, returns) => {
                return new MappedUser(returns.id, user.firstName, user.lastName, user.handle, user.email);
            },
            selectTransform: (row) => {
                const names = row.name.split(' ');
                return new MappedUser(row.id, names[0], names[1], row.handle, row.email);
            },
        });
        // test updating a non-existent user
        const updateReturn1 = yield userMapper
            .update({ id: 1 })
            .returnOne(new MappedUser(1, insertedUser1.firstName, insertedUser1.lastName, insertedUser1.handle, insertedUser1.email));
        expect(updateReturn1).toEqual(null);
        // test inserting a user
        const insertedUser = new MappedUser(0, insertedUser1.firstName, insertedUser1.lastName, insertedUser1.handle, insertedUser1.email);
        const insertReturn = (yield userMapper.insert().returnOne(insertedUser));
        insertReturn === null || insertReturn === void 0 ? void 0 : insertReturn.firstName; // ensure 'firstName' is accessible
        expect(insertReturn).not.toBeNull();
        expect(insertReturn.serialNo).toBeGreaterThan(0);
        // test getting a user by ID
        const selectedUser1 = yield userMapper
            .select({ id: insertReturn.serialNo })
            .returnOne();
        selectedUser1 === null || selectedUser1 === void 0 ? void 0 : selectedUser1.firstName; // ensure 'firstName' is accessible
        expect(selectedUser1).toEqual(insertReturn);
        expect(selectedUser1 === null || selectedUser1 === void 0 ? void 0 : selectedUser1.serialNo).toEqual(insertReturn.serialNo);
        // test updating a user
        const updatingUser = new MappedUser(selectedUser1.serialNo, selectedUser1.firstName, 'Xana', selectedUser1.handle, selectedUser1.email);
        const updateReturn2 = yield userMapper
            .update({ id: updatingUser.serialNo })
            .returnOne(updatingUser);
        updateReturn2 === null || updateReturn2 === void 0 ? void 0 : updateReturn2.firstName; // ensure 'firstName' is accessible
        expect(updateReturn2).toEqual(updatingUser);
        const selectedUser2 = yield userMapper
            .select({ id: insertReturn.serialNo })
            .returnOne();
        selectedUser2 === null || selectedUser2 === void 0 ? void 0 : selectedUser2.firstName; // ensure 'firstName' is accessible
        expect(selectedUser2 === null || selectedUser2 === void 0 ? void 0 : selectedUser2.serialNo).toEqual(selectedUser1.serialNo);
        expect(selectedUser2 === null || selectedUser2 === void 0 ? void 0 : selectedUser2.handle).toEqual(selectedUser1.handle + '2');
        // test updating multiple users
        const updatingUser3 = new MappedUser(selectedUser1.serialNo, 'Every', 'One', selectedUser1.handle, selectedUser1.email);
        const updateReturn3 = yield userMapper.update().returnAll(updatingUser3);
        expect(updateReturn3).toEqual([updatingUser3]);
        updateReturn3[0].serialNo; // ensure 'serialNo' is accessible
        const updateReturn4 = yield userMapper.update().returnOne(updatingUser3);
        expect(updateReturn4).toEqual(updatingUser3);
        updateReturn4 === null || updateReturn4 === void 0 ? void 0 : updateReturn4.serialNo; // ensure 'serialNo' is accessible
        // test deleting a user
        const deleted = yield userMapper
            .delete({ id: insertReturn.serialNo })
            .run();
        expect(deleted).toEqual(true);
        const selectedUser3 = yield userMapper
            .select({ id: insertReturn.serialNo })
            .returnOne();
        expect(selectedUser3).toBeNull();
    }));
});
//# sourceMappingURL=sample-mappers.test.js.map