kysely-mapper
Version:
Flexible Kysely-based utility for mapping between tables and objects
209 lines • 9.97 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 { createInsertTransformMapper } from './utils/test-mappers';
import { userRow1, userRow2, userRow3, insertedUser1, insertedUser2, insertedUser3, insertReturnedUser1, insertReturnedUser2, insertReturnedUser3, } from './utils/test-objects';
import { ReturnedUser, SelectedUser } 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('inserting with transformation', () => {
it('transforms users for insertion without transforming return', () => __awaiter(void 0, void 0, void 0, function* () {
const insertTransformMapper = createInsertTransformMapper(db);
const insertReturn = yield insertTransformMapper
.insert()
.returnOne(insertedUser1);
const readUser1 = yield insertTransformMapper
.select({
id: insertReturn.id,
})
.returnOne();
expect(readUser1 === null || readUser1 === void 0 ? void 0 : readUser1.name).toEqual(`${insertedUser1.firstName} ${insertedUser1.lastName}`);
yield insertTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
const readUsers = yield insertTransformMapper
.select('id', '>', insertReturn.id)
.returnAll();
expect(readUsers.length).toEqual(2);
expect(readUsers[0].name).toEqual(`${insertedUser2.firstName} ${insertedUser2.lastName}`);
expect(readUsers[1].name).toEqual(`${insertedUser3.firstName} ${insertedUser3.lastName}`);
}));
it('transforms insertion return into object without transforming insertion', () => __awaiter(void 0, void 0, void 0, function* () {
const insertReturnTransformMapper = new TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, returns) => {
const names = returns.name.split(' ');
return new ReturnedUser(returns.id, names[0], names[1], source.handle, source.email || null);
},
countTransform: (count) => Number(count),
});
const insertReturn = yield insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(insertReturnedUser1);
const insertReturns = yield insertReturnTransformMapper
.insert()
.returnAll([userRow2, userRow3]);
expect(insertReturns).toEqual([insertReturnedUser2, 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 TableMapper(db, 'users', {
insertReturnColumns: ['id'],
}).withTransforms({
insertReturnTransform: (_source, returns) => returns.id,
countTransform: (count) => Number(count),
});
const insertReturn = yield insertReturnTransformMapper
.insert()
.returnOne(userRow1);
expect(insertReturn).toEqual(1);
// ensure return type can be accessed as a number
((_) => { })(insertReturn);
const insertReturns = yield insertReturnTransformMapper
.insert()
.returnAll([userRow2, 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 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 ReturnedUser(returns.id, source.firstName, source.lastName, source.handle, source.email),
countTransform: (count) => Number(count),
});
const insertReturn = yield insertAndReturnTransformMapper
.insert()
.returnOne(insertedUser1);
expect(insertReturn).toEqual(insertReturnedUser1);
// ensure return type can be accessed as a ReturnedUser
((_) => { })(insertReturn.firstName);
const insertReturns = yield insertAndReturnTransformMapper
.insert()
.returnAll([insertedUser2, insertedUser3]);
expect(insertReturns).toEqual([insertReturnedUser2, 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 TableMapper(db, 'users', {
insertReturnColumns: ['id', 'name'],
updateReturnColumns: ['id', 'name'],
}).withTransforms({
insertReturnTransform: (source, results) => {
const names = results.name.split(' ');
return SelectedUser.create(results.id, {
firstName: names[0],
lastName: names[1],
handle: source.handle,
email: source.email || null,
});
},
updateTransform: (source) => {
if (source instanceof SelectedUser) {
return {
name: `${source.firstName} ${source.lastName}`,
handle: source.handle,
email: source.email,
};
}
return source;
},
selectTransform: (row) => {
const names = row.name.split(' ');
return SelectedUser.create(row.id, {
firstName: names[0],
lastName: names[1],
handle: row.handle,
email: row.email,
});
},
});
// test returnOne()
const names1 = userRow1.name.split(' ');
const expectedUser1 = SelectedUser.create(1, {
firstName: names1[0],
lastName: names1[1],
handle: userRow1.handle,
email: userRow1.email,
});
const insertReturn = yield transformMapper.insert().returnOne(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 = userRow2.name.split(' ');
const expectedUser2 = SelectedUser.create(2, {
firstName: names2[0],
lastName: names2[1],
handle: userRow2.handle,
email: userRow2.email,
});
const names3 = userRow3.name.split(' ');
const expectedUser3 = SelectedUser.create(3, {
firstName: names3[0],
lastName: names3[1],
handle: userRow3.handle,
email: userRow3.email,
});
const insertReturns = yield transformMapper
.insert()
.returnAll([userRow2, 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