kysely-mapper
Version:
Flexible Kysely-based utility for mapping between tables and objects
211 lines • 10.7 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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const table_mapper_1 = require("../mappers/table-mapper");
const test_setup_1 = require("./utils/test-setup");
const test_mappers_1 = require("./utils/test-mappers");
const test_objects_1 = require("./utils/test-objects");
const test_types_1 = require("./utils/test-types");
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('inserting with transformation', () => {
it('transforms users for insertion without transforming return', () => __awaiter(void 0, void 0, void 0, function* () {
const insertTransformMapper = (0, test_mappers_1.createInsertTransformMapper)(db);
const insertReturn = yield insertTransformMapper
.insert()
.returnOne(test_objects_1.insertedUser1);
const readUser1 = yield insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1 === null || readUser1 === void 0 ? void 0 : readUser1.name).toEqual(`${test_objects_1.insertedUser1.firstName} ${test_objects_1.insertedUser1.lastName}`);
yield insertTransformMapper
.insert()
.returnAll([test_objects_1.insertedUser2, test_objects_1.insertedUser3]);
const readUsers = yield insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(`${test_objects_1.insertedUser2.firstName} ${test_objects_1.insertedUser2.lastName}`);
expect(readUsers[1].name).toEqual(`${test_objects_1.insertedUser3.firstName} ${test_objects_1.insertedUser3.lastName}`);
}));
it('transforms insertion return into object without transforming insertion', () => __awaiter(void 0, void 0, void 0, function* () {
const insertReturnTransformMapper = new table_mapper_1.TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new test_types_1.ReturnedUser(returns.id, names[0], names[1], source.handle, source.email || null);
},
countTransform: (count) => Number(count),
});
const insertReturn = yield insertReturnTransformMapper
.insert()
.returnOne(test_objects_1.userRow1);
expect(insertReturn).toEqual(test_objects_1.insertReturnedUser1);
const insertReturns = yield insertReturnTransformMapper
.insert()
.returnAll([test_objects_1.userRow2, test_objects_1.userRow3]);
expect(insertReturns).toEqual([test_objects_1.insertReturnedUser2, test_objects_1.insertReturnedUser3]);
// test that updates return table rows
const updatedUser = yield insertReturnTransformMapper
.update({ id: insertReturn.id })
.returnOne({ name: 'Updated Name' });
expect(updatedUser).toEqual({ id: insertReturn.id, name: 'Updated Name' });
// ensure return type can be accessed as a row
((_) => { })(updatedUser.name);
}));
it('transforms insertion return into primitive without transforming insertion', () => __awaiter(void 0, void 0, void 0, function* () {
const insertReturnTransformMapper = new table_mapper_1.TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = yield insertReturnTransformMapper
.insert()
.returnOne(test_objects_1.userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_) => { })(insertReturn);
const insertReturns = yield insertReturnTransformMapper
.insert()
.returnAll([test_objects_1.userRow2, test_objects_1.userRow3]);
expect(insertReturns).toEqual([2, 3]);
// ensure return type can be accessed as a number
((_) => { })(insertReturns[0]);
}));
it("transforms insertion and insertion return, columns is ['*']", () => __awaiter(void 0, void 0, void 0, function* () {
expect.assertions(5);
const insertAndReturnTransformMapper = new table_mapper_1.TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertTransform: (source, columns) => {
expect(columns).toEqual(['*']);
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
},
insertReturnTransform: (source, returns) => new test_types_1.ReturnedUser(returns.id, source.firstName, source.lastName, source.handle, source.email),
countTransform: (count) => Number(count),
});
const insertReturn = yield insertAndReturnTransformMapper
.insert()
.returnOne(test_objects_1.insertedUser1);
expect(insertReturn).toEqual(test_objects_1.insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_) => { })(insertReturn.firstName);
const insertReturns = yield insertAndReturnTransformMapper
.insert()
.returnAll([test_objects_1.insertedUser2, test_objects_1.insertedUser3]);
expect(insertReturns).toEqual([test_objects_1.insertReturnedUser2, test_objects_1.insertReturnedUser3]);
// ensure return type can be accessed as a ReturnedUser
((_) => { })(insertReturns[0].firstName);
}));
it('returns SelectedObject with updates returning rows', () => __awaiter(void 0, void 0, void 0, function* () {
const transformMapper = new table_mapper_1.TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return test_types_1.SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (source) => {
if (source instanceof test_types_1.SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return test_types_1.SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = test_objects_1.userRow1.name.split(' ');
const expectedUser1 = test_types_1.SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: test_objects_1.userRow1.handle,
email: test_objects_1.userRow1.email,
});
const insertReturn = yield transformMapper.insert().returnOne(test_objects_1.userRow1);
expect(insertReturn).toEqual(expectedUser1);
// ensure return type can be accessed as a SelectedUser
((_) => { })(insertReturn.firstName);
const readUser = yield transformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser).toEqual(expectedUser1);
// test returnAll()
const names2 = test_objects_1.userRow2.name.split(' ');
const expectedUser2 = test_types_1.SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: test_objects_1.userRow2.handle,
email: test_objects_1.userRow2.email,
});
const names3 = test_objects_1.userRow3.name.split(' ');
const expectedUser3 = test_types_1.SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: test_objects_1.userRow3.handle,
email: test_objects_1.userRow3.email,
});
const insertReturns = yield transformMapper
.insert()
.returnAll([test_objects_1.userRow2, test_objects_1.userRow3]);
expect(insertReturns).toEqual([expectedUser2, expectedUser3]);
// ensure return type can be accessed as a SelectedUser
((_) => { })(insertReturns[0].firstName);
((_) => { })(insertReturns[1].firstName);
const readUsers = yield transformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers).toEqual([expectedUser2, expectedUser3]);
// test that updates return rows
const updateReturn = yield transformMapper
.update({ id: 1 })
.returnOne(expectedUser2);
expect(updateReturn).toEqual({
id: 1,
name: `${expectedUser2.firstName} ${expectedUser2.lastName}`,
});
// ensure return type can be accessed as a row
((_) => { })(updateReturn.name);
}));
});
//# sourceMappingURL=insert-transforms.test.js.map