kysely-mapper/dist/esm/tests/update-transform.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 { TableMapper } from '../mappers/table-mapper';
import { createDB, resetDB, destroyDB } from './utils/test-setup';
import { userObject1, userRow1, userRow2, userRow3, } from './utils/test-objects';
import { ReturnedUser, UpdatingUser } from './utils/test-types';
let db;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
    db = yield createDB();
}));
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('updating with transformation', () => {
    it('transforms users for update without transforming return', () => __awaiter(void 0, void 0, void 0, function* () {
        const mapper = new TableMapper(db, 'users', {
            insertReturnColumns: ['id'],
            updateReturnColumns: ['id'],
        }).withTransforms({
            updateTransform: (source) => ({
                name: `${source.firstName} ${source.lastName}`,
                handle: source.handle,
                email: source.email,
            }),
        });
        const insertReturns = yield mapper
            .insert()
            .returnAll([userRow1, userRow2, userRow3]);
        const updatingUser1 = UpdatingUser.create(0, Object.assign({}, userObject1, { firstName: 'Suzanne' }));
        const updateReturns = yield mapper
            .update(({ or, cmpr }) => or([
            cmpr('id', '=', insertReturns[0].id),
            cmpr('id', '=', insertReturns[2].id),
        ]))
            .returnAll(updatingUser1);
        expect(updateReturns).toEqual([
            { id: insertReturns[0].id },
            { id: insertReturns[2].id },
        ]);
        const readUsers = yield mapper
            .select()
            .modify((qb) => qb.orderBy('id'))
            .returnAll();
        expect(readUsers).toEqual([
            Object.assign({}, userRow1, {
                id: insertReturns[0].id,
                name: 'Suzanne Smith',
            }),
            Object.assign({}, userRow2, { id: insertReturns[1].id }),
            Object.assign({}, userRow1, {
                id: insertReturns[2].id,
                name: 'Suzanne Smith',
            }),
        ]);
    }));
    it('transforms update return into object without transforming update', () => __awaiter(void 0, void 0, void 0, function* () {
        const updateReturnTransformMapper = new TableMapper(db, 'users', {
            insertReturnColumns: ['id'],
            updateReturnColumns: ['id'],
        }).withTransforms({
            updateReturnTransform: (source, returns) => new ReturnedUser(returns.id, source.name ? source.name.split(' ')[0] : '(first)', source.name ? source.name.split(' ')[1] : '(last)', source.handle ? source.handle : '(handle)', source.email ? source.email : '(email)'),
        });
        const insertReturn = yield updateReturnTransformMapper
            .insert()
            .returnOne(userRow1);
        const updateReturn1 = yield updateReturnTransformMapper
            .update({ id: insertReturn.id })
            .returnAll({ name: 'Suzanne Smith' });
        expect(updateReturn1).toEqual([
            new ReturnedUser(insertReturn.id, 'Suzanne', 'Smith', '(handle)', '(email)'),
        ]);
        // Ensure the returned value is accessible as a ReturnedUser
        ((_) => { })(updateReturn1[0].firstName);
        const updateReturn2 = yield updateReturnTransformMapper
            .update({ id: insertReturn.id })
            .returnOne({ name: 'Suzanne Smithy' });
        expect(updateReturn2).toEqual(new ReturnedUser(insertReturn.id, 'Suzanne', 'Smithy', '(handle)', '(email)'));
        // Ensure the returned value is accessible as a ReturnedUser
        ((_) => { })(updateReturn2.firstName);
    }));
    it('transforms update return into primitive without transforming update', () => __awaiter(void 0, void 0, void 0, function* () {
        const updateReturnTransformMapper = new TableMapper(db, 'users', {
            insertReturnColumns: ['id'],
            updateReturnColumns: ['id'],
        }).withTransforms({
            insertReturnTransform: (_source, returns) => returns.id,
            updateReturnTransform: (_source, returns) => returns.id,
        });
        const insertReturn = yield updateReturnTransformMapper
            .insert()
            .returnOne(userRow1);
        const updateReturn1 = yield updateReturnTransformMapper
            .update({ id: insertReturn })
            .returnAll({ name: 'Suzanne Smith' });
        expect(updateReturn1).toEqual([1]);
        // Ensure the returned value is accessible as a number
        ((_) => { })(updateReturn1[0]);
        const updateReturn2 = yield updateReturnTransformMapper
            .update({ id: insertReturn })
            .returnOne({ name: 'Suzanne Smithy' });
        expect(updateReturn2).toEqual(1);
        // Ensure the returned value is accessible as a number
        ((_) => { })(updateReturn2);
    }));
    it("transforms update and update return, columns is ['*']", () => __awaiter(void 0, void 0, void 0, function* () {
        expect.assertions(2);
        const updateAndReturnTransformMapper = new TableMapper(db, 'users', {
            insertReturnColumns: ['id'],
            updateReturnColumns: ['id'],
        }).withTransforms({
            updateTransform: (source, columns) => {
                expect(columns).toEqual(['*']);
                return {
                    name: `${source.firstName} ${source.lastName}`,
                    handle: source.handle,
                    email: source.email,
                };
            },
            updateReturnTransform: (source, returns) => new ReturnedUser(returns.id, source.firstName, source.lastName, source.handle, source.email),
        });
        const insertReturn = yield updateAndReturnTransformMapper
            .insert()
            .returnOne(userRow1);
        const updateReturn = yield updateAndReturnTransformMapper
            .update({ id: insertReturn.id })
            .returnAll(UpdatingUser.create(0, userObject1));
        expect(updateReturn).toEqual([
            new ReturnedUser(insertReturn.id, userObject1.firstName, userObject1.lastName, userObject1.handle, userObject1.email),
        ]);
        // Ensure the returned value is accessible as a ReturnedUser
        ((_) => { })(updateReturn[0].firstName);
    }));
    it('transforms a union of updating object types', () => __awaiter(void 0, void 0, void 0, function* () {
        const mapper = new TableMapper(db, 'users', {
            keyColumns: ['id'],
        }).withTransforms({
            updateTransform: (source) => source instanceof UpdatingUser
                ? {
                    name: `${source.firstName} ${source.lastName}`,
                    handle: source.handle,
                    email: source.email,
                }
                : source,
        });
        const insertReturn = yield mapper.insert().returnOne(userRow1);
        // test with UpdatingUser
        yield mapper
            .update({ id: insertReturn.id })
            .columns(['name'])
            .run(UpdatingUser.create(0, userObject1));
        const readUser1 = yield mapper.select(insertReturn.id).returnOne();
        expect(readUser1).toEqual({
            id: insertReturn.id,
            name: `${userObject1.firstName} ${userObject1.lastName}`,
            email: userRow1.email,
            handle: userRow1.handle,
        });
        // test with Updateable<Users>
        const newName = 'Suzanne Smith Something';
        yield mapper.update({ id: insertReturn.id }).run({ name: newName });
        const readUser2 = yield mapper.select(insertReturn.id).returnOne();
        expect(readUser2).toEqual({
            id: insertReturn.id,
            name: newName,
            email: userRow1.email,
            handle: userRow1.handle,
        });
    }));
});
//# sourceMappingURL=update-transform.test.js.map