kysely-mapper
Version:
Flexible Kysely-based utility for mapping between tables and objects
196 lines • 11.2 kB
JavaScript
"use strict";
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const test_setup_1 = require("./utils/test-setup");
const test_objects_1 = require("./utils/test-objects");
const table_mapper_1 = require("../mappers/table-mapper");
const entire_row_transforms_1 = require("../mappers/entire-row-transforms");
let db;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
db = yield (0, test_setup_1.createDB)();
}));
beforeEach(() => (0, test_setup_1.resetDB)(db));
afterAll(() => (0, test_setup_1.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 table_mapper_1.TableMapper(db, 'users', {
keyColumns,
updateReturnColumns: ['id', 'name'],
}).withTransforms(new entire_row_transforms_1.EntireRowTransforms(keyColumns));
// test updating a non-existent user
const userWithID = new MappedUser(1, test_objects_1.USERS[0].name, test_objects_1.USERS[0].handle, test_objects_1.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, test_objects_1.USERS[0].name, test_objects_1.USERS[0].handle, test_objects_1.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, test_objects_1.USERS[1].name, test_objects_1.USERS[1].handle, test_objects_1.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 table_mapper_1.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, test_objects_1.insertedUser1.firstName, test_objects_1.insertedUser1.lastName, test_objects_1.insertedUser1.handle, test_objects_1.insertedUser1.email));
expect(updateReturn1).toEqual(null);
// test inserting a user
const insertedUser = new MappedUser(0, test_objects_1.insertedUser1.firstName, test_objects_1.insertedUser1.lastName, test_objects_1.insertedUser1.handle, test_objects_1.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