kysely-mapper
Version:
Flexible Kysely-based utility for mapping between tables and objects
146 lines • 7.1 kB
JavaScript
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 { USERS } from './utils/test-objects';
import { ignore } from './utils/test-utils';
import { User } from './utils/test-types';
import { createUserMapperReturningAll, createUserMapperReturningNothing, } from './utils/test-mappers';
let db;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
db = yield createDB();
userMapperReturningNothing = createUserMapperReturningNothing(db);
userMapperReturningAll = createUserMapperReturningAll(db);
}));
beforeEach(() => resetDB(db));
afterAll(() => destroyDB(db));
let userMapperReturningNothing;
let userMapperReturningAll;
describe('compiled insertions', () => {
it('compiles a non-returning insert query without transformation', () => __awaiter(void 0, void 0, void 0, function* () {
const compilation = userMapperReturningNothing
.insert()
.columns(['name', 'handle'])
.compile();
// test run()
const success1 = yield compilation.run(USERS[1]);
expect(success1).toBe(true);
// test returnOne()
const success2 = yield compilation.returnOne(USERS[2]);
expect(success2).toBeUndefined();
const readUsers = yield userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].handle).toEqual(USERS[1].handle);
expect(readUsers[0].email).toEqual(null);
expect(readUsers[1].handle).toEqual(USERS[2].handle);
expect(readUsers[1].email).toEqual(null);
}));
it('compiles a returning insert query without transformation', () => __awaiter(void 0, void 0, void 0, function* () {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
// test returnOne()
const insertReturn = yield compilation.returnOne(USERS[0]);
expect(insertReturn).toEqual(Object.assign(Object.assign({}, USERS[0]), { id: 1 }));
// Ensure that the provided columns are accessible
((_) => { })(insertReturn.name);
// test run()
const success1 = yield compilation.run(USERS[1]);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = yield compilation.run(Object.assign(Object.assign({}, USERS[2]), { id: 100 }));
expect(success2).toBe(true);
const readUsers = yield userMapperReturningAll.select().returnAll();
expect(readUsers.length).toEqual(3);
expect(readUsers[0].handle).toEqual(USERS[0].handle);
expect(readUsers[1].handle).toEqual(USERS[1].handle);
expect(readUsers[2].handle).toEqual(USERS[2].handle);
expect(readUsers[2].id).toEqual(3);
ignore('check compile-time types', () => {
compilation.returnOne({
name: 'xyz',
handle: 'pdq',
email: 'abc@def.hij',
// @ts-expect-error - only insertable columns are allowed
notThere: 32,
});
// @ts-expect-error - only expected columns are returned
insertReturn.notThere;
});
}));
it('compiles an insert query with transformation', () => __awaiter(void 0, void 0, void 0, function* () {
expect.assertions(7);
const columnSubset = [
'name',
'handle',
'email',
];
const transformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
selectTransform: (row) => {
const names = row.name.split(' ');
return new User(row.id, names[0], names[1], row.handle, row.email);
},
insertTransform: (source, columns) => {
expect(columns).toEqual(columnSubset);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source, returns) => new User(returns.id, source.firstName, source.lastName, source.handle, source.email),
countTransform: (count) => Number(count),
});
const user1 = new User(0, 'John', 'Doe', 'johndoe', 'jdoe@abc.def');
const user2 = new User(0, 'Sam', 'Gamgee', 'sg', 'sg@abc.def');
const user3 = new User(100, 'Sue', 'Rex', 'srex', 'srex@abc.def');
const compilation = transformMapper
.insert()
.columns(columnSubset)
.compile();
// test returnOne()
const insertReturn = yield compilation.returnOne(user1);
expect(insertReturn).toEqual(User.create(1, user1));
// Ensure that the provided columns are accessible
((_) => { })(insertReturn.firstName);
// test run()
const success1 = yield compilation.run(user2);
expect(success1).toBe(true);
// test that non-specified columns are not inserted
const success2 = yield compilation.run(user3);
expect(success2).toBe(true);
const readUsers = yield transformMapper.select().returnAll();
expect(readUsers).toEqual([
User.create(1, user1),
User.create(2, user2),
User.create(3, user3),
]);
ignore('check compile-time types', () => {
// @ts-expect-error - only insertable objecs are allowed
compilation.returnOne(USERS[0]);
// @ts-expect-error - only insertable objecs are allowed
compilation.run(USERS[0]);
});
}));
it('requires all indicated columns to be inserted', () => __awaiter(void 0, void 0, void 0, function* () {
const compilation = userMapperReturningAll
.insert()
.columns(['name', 'handle', 'email'])
.compile();
const insertValues = { name: 'John Doe', handle: 'johndoe' };
expect(() => compilation.returnOne(insertValues)).rejects.toThrow(`column 'email' missing`);
const success = yield compilation.run(Object.assign(Object.assign({}, insertValues), { email: null }));
expect(success).toBe(true);
}));
});
//# sourceMappingURL=insert-compile.test.js.map