kysely-mapper
Version:
Flexible Kysely-based utility for mapping between tables and objects
203 lines • 11.1 kB
JavaScript
;
/**
* Tests TableMapper.selectMany(), TableMapper.selectOne(), and query filters.
*/
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_utils_1 = require("./utils/test-utils");
let db;
let userMapper;
let userMapperReturningNothing;
beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
db = yield (0, test_setup_1.createDB)();
userMapper = (0, test_mappers_1.createUserMapperReturningID)(db);
userMapperReturningNothing = (0, test_mappers_1.createUserMapperReturningNothing)(db);
}));
beforeEach(() => (0, test_setup_1.resetDB)(db));
afterAll(() => (0, test_setup_1.destroyDB)(db));
describe('general selection', () => {
it('compiles an unparameterized select query', () => __awaiter(void 0, void 0, void 0, function* () {
yield userMapper.insert().run(test_objects_1.USERS);
const compilation = userMapper.select({ name: test_objects_1.USERS[0].name }).compile();
const users = yield compilation.returnAll({});
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(test_objects_1.USERS[0].handle);
expect(users[1].handle).toEqual(test_objects_1.USERS[2].handle);
// Ensure that the provided columns are not optional
((_) => { })(users[0].handle);
const user = yield compilation.returnOne({});
expect(user === null || user === void 0 ? void 0 : user.handle).toEqual(test_objects_1.USERS[0].handle);
// Ensure that the provided columns are not optional
((_) => { })(user.name);
(0, test_utils_1.ignore)('compilation type errors', () => {
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user.notThere;
});
}));
it('parameterizes and compiles a select query', () => __awaiter(void 0, void 0, void 0, function* () {
yield userMapper.insert().run(test_objects_1.USERS);
const parameterization = userMapper.parameterize(({ mapper, param }) => mapper.select({ name: param('name') }));
// test returnAll() returning multiple
const users = yield parameterization.returnAll({ name: test_objects_1.USERS[0].name });
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(test_objects_1.USERS[0].handle);
expect(users[1].handle).toEqual(test_objects_1.USERS[2].handle);
// Ensure that the provided columns are not optional
((_) => { })(users[0].handle);
// test returnAll() returning none
const users2 = yield parameterization.returnAll({ name: 'not there' });
expect(users2.length).toEqual(0);
// test returnOne() returning one
const user = yield parameterization.returnOne({ name: test_objects_1.USERS[1].name });
expect(user === null || user === void 0 ? void 0 : user.handle).toEqual(test_objects_1.USERS[1].handle);
// Ensure that the provided columns are not optional
((_) => { })(user.name);
// test returnOne() returning none
const user2 = yield parameterization.returnOne({ name: 'not there' });
expect(user2).toBeNull();
(0, test_utils_1.ignore)('parameterization type errors', () => {
// @ts-expect-error - errors on invalid parameter names
parameterization.returnAll({ notThere: 'foo' });
// @ts-expect-error - errors on invalid column names
users[0].notThere;
// @ts-expect-error - errors on invalid column names
user.notThere;
userMapper.parameterize(
// @ts-expect-error - errors on invalid parameter name
({ mapper, param }) => mapper.select({ name: param('notThere') }));
userMapper.parameterize(
// @ts-expect-error - errors on invalid parameter type
({ mapper, param }) => mapper.select({ name: param('name') }));
// @ts-expect-error - errors on invalid parameter value name
parameterization.returnOne({ notThere: 'foo' });
// @ts-expect-error - errors on invalid parameter value type
parameterization.returnOne({ name: 123 });
});
}));
it('modifies the underlying query builder', () => __awaiter(void 0, void 0, void 0, function* () {
yield userMapper.insert().run(test_objects_1.USERS);
const users = yield userMapper
.select()
.modify((qb) => qb.where('name', '=', test_objects_1.USERS[0].name).orderBy('handle', 'desc'))
.returnAll();
expect(users.length).toEqual(2);
expect(users[0].handle).toEqual(test_objects_1.USERS[2].handle);
expect(users[1].handle).toEqual(test_objects_1.USERS[0].handle);
const user = yield userMapper
.select()
.modify((qb) => qb.where('name', '=', test_objects_1.USERS[0].name).orderBy('handle', 'desc'))
.returnOne();
expect(user === null || user === void 0 ? void 0 : user.handle).toEqual(test_objects_1.USERS[2].handle);
}));
it('does not modify the underlying selected columns', () => __awaiter(void 0, void 0, void 0, function* () {
yield userMapper.insert().run(test_objects_1.USERS);
const users = yield userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnAll();
expect(users).toEqual([
Object.assign(Object.assign({}, test_objects_1.USERS[2]), { id: 3 }),
Object.assign(Object.assign({}, test_objects_1.USERS[1]), { id: 2 }),
Object.assign(Object.assign({}, test_objects_1.USERS[0]), { id: 1 }),
]);
// Ensure that columns can be addressed by name.
((_) => { })(users[0].id);
((_) => { })(users[0].handle);
((_) => { })(users[0].name);
((_) => { })(users[0].email);
const user = yield userMapper
.select()
.modify((qb) => qb.select('name').orderBy('handle', 'desc'))
.returnOne();
expect(user).toEqual(Object.assign(Object.assign({}, test_objects_1.USERS[2]), { id: 3 }));
// Ensure that columns can be addressed by name.
((_) => { })(user.id);
((_) => { })(user.handle);
((_) => { })(user.name);
((_) => { })(user.email);
(0, test_utils_1.ignore)('detects modify() type errors', () => __awaiter(void 0, void 0, void 0, function* () {
// @ts-expect-error - cannot access invalid columns
users[0].notThere;
// @ts-expect-error - cannot access invalid columns
user.notThere;
}));
}));
it('selects via a multi-column key tuple (definition order)', () => __awaiter(void 0, void 0, void 0, function* () {
const mapper = new table_mapper_1.TableMapper(db, 'users', {
keyColumns: ['id', 'name'],
});
yield mapper.insert().run(test_objects_1.USERS);
const users = yield mapper.select([3, 'Sue']).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(test_objects_1.USERS[2].name);
(0, test_utils_1.ignore)('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
}));
it('selects via a multi-column key tuple (different order)', () => __awaiter(void 0, void 0, void 0, function* () {
const mapper = new table_mapper_1.TableMapper(db, 'users', {
keyColumns: ['name', 'id'],
});
yield mapper.insert().run(test_objects_1.USERS);
const users = yield mapper.select(['Sue', 3]).returnAll();
expect(users.length).toEqual(1);
expect(users[0].name).toEqual(test_objects_1.USERS[2].name);
(0, test_utils_1.ignore)('detects key colum tuple type errors', () => {
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue']);
// @ts-expect-error - key tuple must have correct length
mapper.select(['Sue', 3, 'foo']);
// @ts-expect-error - key tuple must have correct types
mapper.select(['Sue', 'foo']);
// @ts-expect-error - primitive key values are not allowed
mapper.select('Sue');
// @ts-expect-error - primitive key values are not allowed
mapper.select(1);
});
}));
(0, test_utils_1.ignore)('detects select(filter) type errors', () => __awaiter(void 0, void 0, void 0, function* () {
// @ts-expect-error - doesn't allow only two arguments
userMapper.select('name', '=');
// @ts-expect-error - object filter fields must be valid
userMapper.select({ notThere: 'xyz' });
userMapper.select(({ or, cmpr }) =>
// @ts-expect-error - where expression columns must be valid
or([cmpr('notThere', '=', 'Sue')]));
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('notThere', '=', 'foo');
// @ts-expect-error - binary op filter fields must be valid
userMapper.select('users.notThere', '=', 'foo');
// @ts-expect-error - ID filter must have correct type
userMapper.select('str');
// @ts-expect-error - ID filter must have correct type
userMapper.select(['str']);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select(1);
// @ts-expect-error - ID filter not allowed when when no ID column
userMapperReturningNothing.select([1]);
}));
});
//# sourceMappingURL=select-general.test.js.map