kysely-mapper/dist/esm/tests/transform-types.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 { User } from './utils/test-types';
import { ignore } from './utils/test-utils';
import { createInsertTransformMapper } from './utils/test-mappers';
let db;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
    db = yield createDB();
}));
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
describe('table mapper transform type checks', () => {
    ignore('detects invalid select transform configuration', () => {
        new TableMapper(db, 'users').withTransforms({
            // @ts-expect-error - invalid select transform
            selectTransform: (user) => user,
        });
    });
    ignore('detects invalid insert transform configuration', () => {
        new TableMapper(db, 'users').withTransforms({
            // @ts-expect-error - invalid insert transform
            insertTransform: (user) => user,
        });
    });
    ignore('detects invalid update transform configuration', () => {
        new TableMapper(db, 'users').withTransforms({
            // @ts-expect-error - invalid update transform
            updateTransform: (_user) => ({ noId: 1 }),
        });
    });
    ignore('detects invalid update return transform return', () => __awaiter(void 0, void 0, void 0, function* () {
        const mapper = new TableMapper(db, 'users', { keyColumns: ['id'] });
        mapper.withTransforms({
            selectTransform: (_user) => new User(1, 'John', 'Doe', 'jdoe', 'x@y.z'),
            updateTransform: (user) => ({
                id: user.id,
                name: `${user.firstName} ${user.lastName}`,
                handle: user.handle,
                email: user.email,
            }),
            updateReturnTransform: (_user, returns) => returns,
        });
        (yield mapper
            .update({ id: 1 })
            // @ts-expect-error - ensure that return type is User
            .returnOne(new User(1, 'John', 'Doe', 'jdoe', 'jdoe@abc.def'))).name;
    }));
    ignore('detects insertion transformation type errors', () => __awaiter(void 0, void 0, void 0, function* () {
        const insertTransformMapper = createInsertTransformMapper(db);
        // @ts-expect-error - requires InsertedObject as input
        yield insertTransformMapper.insert().returnOne(USERS[0]);
        // @ts-expect-error - requires InsertedObject as input
        yield insertTransformMapper.insert().run(USERS[0]);
        // @ts-expect-error - requires InsertedObject as input
        yield insertTransformMapper.insert().returnOne(selectedUser1);
        // @ts-expect-error - requires InsertedObject as input
        yield insertTransformMapper.insert().run(selectedUser1);
    }));
    it('accepts readonly transforms', () => {
        const transforms = {
            countTransform: (count) => count,
        };
        new TableMapper(db, 'users', {}).withTransforms(transforms);
    });
});
//# sourceMappingURL=transform-types.test.js.map