@decaf-ts/for-postgres
Version:
template for ts projects
886 lines • 126 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.PostgresAdapter = void 0;
exports.createdByOnPostgresCreateUpdate = createdByOnPostgresCreateUpdate;
const core_1 = require("@decaf-ts/core");
const constants_1 = require("./constants.cjs");
const db_decorators_1 = require("@decaf-ts/db-decorators");
require("reflect-metadata");
const decorator_validation_1 = require("@decaf-ts/decorator-validation");
const errors_1 = require("./errors.cjs");
const query_1 = require("./query/index.cjs");
const pg_1 = require("pg");
const sequences_1 = require("./sequences/index.cjs");
const indexes_1 = require("./indexes/index.cjs");
const reflection_1 = require("@decaf-ts/reflection");
const PostgresRepository_1 = require("./PostgresRepository.cjs");
const logging_1 = require("@decaf-ts/logging");
const PostgresDispatch_1 = require("./PostgresDispatch.cjs");
const utils_1 = require("./utils.cjs");
async function createdByOnPostgresCreateUpdate(context, data, key, model) {
try {
const user = context.get("user");
model[key] = user;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
}
catch (e) {
throw new db_decorators_1.InternalError("No User found in context. Please provide a user in the context");
}
}
/**
* @description Abstract adapter for Postgres database operations
* @summary Provides a base implementation for Postgres database operations, including CRUD operations, sequence management, and error handling
* @template Y - The scope type
* @template F - The repository flags type
* @template C - The context type
* @param {Y} scope - The scope for the adapter
* @param {string} flavour - The flavour of the adapter
* @param {string} [alias] - Optional alias for the adapter
* @class PostgresAdapter
*/
class PostgresAdapter extends core_1.Adapter {
constructor(pool, alias) {
super(pool, constants_1.PostgresFlavour, alias);
}
async flags(operation, model, flags) {
const f = await super.flags(operation, model, flags);
const newObj = {
user: (await PostgresAdapter.getCurrentUser(this.native)),
};
if (operation === "create" || operation === "update") {
const pk = (0, db_decorators_1.findPrimaryKey)(new model()).id;
newObj.ignoredValidationProperties = (f.ignoredValidationProperties ? f.ignoredValidationProperties : []).concat(pk);
}
return Object.assign(f, newObj);
}
Dispatch() {
return new PostgresDispatch_1.PostgresDispatch();
}
repository() {
return PostgresRepository_1.PostgresRepository;
}
/**
* @description Creates a new Postgres statement for querying
* @summary Factory method that creates a new PostgresStatement instance for building queries
* @template M - The model type
* @return {PostgresStatement<M, any>} A new PostgresStatement instance
*/
Statement() {
return new query_1.PostgresStatement(this);
}
/**
* @description Creates a new PostgreSQL sequence
* @summary Factory method that creates a new PostgreSQLSequence instance for managing sequences
* @param {SequenceOptions} options - The options for the sequence
* @return {Promise<Sequence>} A promise that resolves to a new Sequence instance
*/
async Sequence(options) {
return new sequences_1.PostgresSequence(options, this);
}
/**
* @description Initializes the adapter by creating indexes for all managed models
* @summary Sets up the necessary database indexes for all models managed by this adapter
* @return {Promise<void>} A promise that resolves when initialization is complete
*/
async initialize() {
const managedModels = core_1.Adapter.models(this.flavour);
return this.index(...managedModels);
}
/**
* @description Creates indexes for the given models
* @summary Abstract method that must be implemented to create database indexes for the specified models
* @template M - The model type
* @param {...Constructor<M>} models - The model constructors to create indexes for
* @return {Promise<void>} A promise that resolves when all indexes are created
*/
async index(...models) {
const indexes = (0, indexes_1.generateIndexes)(models);
const client = await this.native.connect();
try {
await client.query("BEGIN");
for (const index of indexes) {
await client.query(index.query, index.values);
}
await client.query("COMMIT");
}
catch (e) {
await client.query("ROLLBACK");
throw this.parseError(e);
}
finally {
client.release();
}
}
/**
* @description Executes a raw SQL query against the database
* @summary Abstract method that must be implemented to execute raw SQL queries
* @template R - The result type
* @param {PostgresQuery} q - The query to execute
* @param {boolean} rowsOnly - Whether to return only the rows or the full response
* @return {Promise<R>} A promise that resolves to the query result
*/
async raw(q, rowsOnly) {
const client = await this.native.connect();
try {
const { query, values } = q;
const response = await client.query(query, values);
if (rowsOnly)
return response.rows;
return response;
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
prepare(model, pk) {
const prepared = super.prepare(model, pk);
prepared.record = Object.entries(prepared.record).reduce((accum, [key, value]) => {
if (key === core_1.PersistenceKeys.METADATA ||
this.isReserved(key) ||
key === pk)
return accum;
if (value === undefined) {
return accum;
}
if (value instanceof Date) {
value = new Date(value.getTime());
}
else {
switch (typeof value) {
case "string":
value = `${value}`;
break;
default:
//do nothing;
}
}
accum[key] = value;
return accum;
}, {});
return prepared;
}
revert(obj, clazz, pk, id, transient) {
const log = this.log.for(this.revert);
const ob = {};
ob[pk] = id || obj[pk];
const m = (typeof clazz === "string" ? decorator_validation_1.Model.build(ob, clazz) : new clazz(ob));
log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
const result = Object.keys(m).reduce((accum, key) => {
accum[key] = obj[core_1.Repository.column(accum, key)];
return accum;
}, m);
if (transient) {
log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
Object.entries(transient).forEach(([key, val]) => {
if (key in result)
throw new db_decorators_1.InternalError(`Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`);
result[key] = val;
});
}
return result;
}
/**
* @description Creates a new record in the database
* @summary Abstract method that must be implemented to create a new record
* @param {string} tableName - The name of the table
* @param {string|number} id - The ID of the record
* @param {Record<string, any>} model - The model to create
* @param {...any[]} args - Additional arguments
* @return {Promise<Record<string, any>>} A promise that resolves to the created record
*/
async create(tableName, id, model,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
const values = Object.values(model);
const sql = `INSERT INTO ${tableName} (${Object.keys(model)}) VALUES (${values.map((_, i) => `$${i + 1}`)}) RETURNING *`;
const response = await this.raw({ query: sql, values: values }, false);
const { rows } = response;
return rows[0];
}
/**
* @description Reads a record from the database
* @summary Abstract method that must be implemented to read a record
* @param {string} tableName - The name of the table
* @param {string|number} id - The ID of the record
* @param {string} pk - primary key colum
* @return {Promise<Record<string, any>>} A promise that resolves to the read record
*/
async read(tableName, id, pk) {
const sql = `SELECT * FROM ${tableName} as t WHERE t.${pk} = $1`;
const result = await this.raw({ query: sql, values: [id] }, false);
if (result.rowCount === 0)
throw new db_decorators_1.NotFoundError(`Record with id: ${id} not found in table ${tableName}`);
return result.rows[0];
}
/**
* @description Updates a record in the database
* @summary Abstract method that must be implemented to update a record
* @param {string} tableName - The name of the table
* @param {string|number} id - The ID of the record
* @param {Record<string, any>} model - The model to update
* @param {string} pk - Additional arguments
* @return A promise that resolves to the updated record
*/
async update(tableName, id, model,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
const values = Object.values(model);
const sql = `UPDATE ${tableName}
SET ${Object.keys(model)
.map((f, i) => `${f} = $${i + 1}`)
.join(", ")}
WHERE id = $${values.length + 1}
RETURNING *;`;
const response = await this.raw({ query: sql, values: [...values, id] }, false);
if (response.rowCount === 0) {
throw new db_decorators_1.NotFoundError(`Record with id: ${id} not found in table ${tableName}`);
}
const { rows } = response;
return rows[0];
}
/**
* @description Deletes a record from the database
* @summary Abstract method that must be implemented to delete a record
* @param {string} tableName - The name of the table
* @param {string|number} id - The ID of the record
* @param {string} pk - Additional arguments
* @return A promise that resolves to the deleted record
*/
async delete(tableName, id, pk,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
const sql = `
DELETE FROM ${tableName}
WHERE ${pk} = $1
RETURNING *
`;
const result = await this.raw({
query: sql,
values: [id],
}, false);
if (result.rowCount === 0) {
throw new db_decorators_1.NotFoundError(`Record with id: ${id} not found in table ${tableName}`);
}
return result.rows[0];
}
async createAll(tableName, id, model,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
const columns = Object.keys(model[0]);
const valuePlaceholders = model
.map((_, recordIndex) => `(${columns
.map((_, colIndex) => `$${recordIndex * columns.length + colIndex + 1}`)
.join(", ")})`)
.join(", ");
const values = model.flatMap((record) => Object.values(record));
const q = `INSERT INTO ${tableName} (${columns.join(", ")})
VALUES ${valuePlaceholders}
RETURNING *;
`;
const result = await this.raw({
query: q,
values: values,
}, false);
return result.rows;
}
async readAll(tableName, id, pk,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
if (!id.length)
return [];
const sql = `
SELECT *
FROM ${tableName}
WHERE ${pk} = ANY($1)
ORDER BY array_position($1::${typeof id[0] === "number" ? "integer" : "text"}[], ${pk})`;
const result = await this.raw({
query: sql,
values: [id],
}, false);
// If we didn't find all requested records, throw an error
if (result.rows.length !== id.length) {
const foundIds = result.rows.map((row) => row[pk]);
const missingIds = id.filter((id) => !foundIds.includes(id));
throw new db_decorators_1.NotFoundError(`Records with ids: ${missingIds.join(", ")} not found in table ${tableName}`);
}
return result.rows;
}
async updateAll(tableName, ids, model, pk,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
if (!ids.length)
return [];
if (ids.length !== model.length) {
throw new db_decorators_1.InternalError("Number of IDs must match number of records");
}
// Create values array and get column names from first record
const columns = Object.keys(model[0]);
const values = [];
let placeholderIndex = 1;
// Generate value lists for each record
const valueLists = model
.map((record, i) => {
const recordValues = columns.map((col) => {
values.push(record[col]);
if (record[col] instanceof Date) {
return `$${placeholderIndex++}::timestamp`;
}
return `$${placeholderIndex++}`;
});
return `(${ids[i]}, ${recordValues.join(", ")})`;
})
.join(", ");
const sql = `
UPDATE ${tableName} AS t SET
${columns.map((col) => `${col} = c.${col}`).join(",\n ")}
FROM (VALUES ${valueLists}) AS c(id, ${columns.join(", ")})
WHERE t.${pk} = c.id
RETURNING *`;
const result = await this.raw({
query: sql,
values,
}, false);
// Verify all records were updated
if (result.rows.length !== ids.length) {
const foundIds = result.rows.map((row) => row[pk]);
const missingIds = ids.filter((id) => !foundIds.includes(id));
throw new db_decorators_1.NotFoundError(`Records with ids: ${missingIds.join(", ")} not found in table ${tableName}`);
}
// Return updated records in the same order as input
return ids.map((id) => result.rows.find((row) => row[pk].toString() === id.toString()));
}
async deleteAll(tableName, ids, pk,
// eslint-disable-next-line @typescript-eslint/no-unused-vars
...args) {
if (!ids.length)
return [];
// First fetch the records that will be deleted (for returning them later)
const fetchSql = `
SELECT *
FROM ${tableName}
WHERE ${pk} = ANY($1)
ORDER BY array_position($1::${typeof ids[0] === "number" ? "integer" : "text"}[], ${pk})`;
const fetchResult = await this.raw({
query: fetchSql,
values: [ids],
}, false);
if (fetchResult.rows.length !== ids.length) {
const foundIds = fetchResult.rows.map((row) => row[pk]);
const missingIds = ids.filter((id) => !foundIds.includes(id));
throw new db_decorators_1.NotFoundError(`Records with ids: ${missingIds.join(", ")} not found in table ${tableName}`);
}
const deleteSql = `
DELETE FROM ${tableName}
WHERE ${pk} = ANY($1)`;
await this.raw({
query: deleteSql,
values: [ids],
}, false);
return ids.map((id) => fetchResult.rows.find((row) => row[pk].toString() === id.toString()));
}
/**
* @description Parses an error and converts it to a BaseError
* @summary Converts various error types to appropriate BaseError subtypes
* @param {Error|string} err - The error to parse
* @param {string} [reason] - Optional reason for the error
* @return {BaseError} The parsed error as a BaseError
*/
parseError(err, reason) {
return PostgresAdapter.parseError(err, reason);
}
/**
* @description Checks if an attribute is reserved
* @summary Determines if an attribute name is reserved in PostgreSQL
* @param {string} attr - The attribute name to check
* @return {boolean} True if the attribute is reserved, false otherwise
*/
isReserved(attr) {
return !!attr.match(constants_1.reservedAttributes);
}
/**
* @description Static method to parse an error and convert it to a BaseError
* @summary Converts various error types to appropriate BaseError subtypes based on PostgreSQL error codes and messages
* @param {Error|string} err - The error to parse
* @param {string} [reason] - Optional reason for the error
* @return {BaseError} The parsed error as a BaseError
* @mermaid
* sequenceDiagram
* participant Caller
* participant parseError
* participant ErrorTypes
*
* Caller->>parseError: err, reason
* Note over parseError: Check if err is already a BaseError
* alt err is BaseError
* parseError-->>Caller: return err
* else err is string
* Note over parseError: Extract code from string
* alt code matches "duplicate key|already exists"
* parseError->>ErrorTypes: new ConflictError(code)
* ErrorTypes-->>Caller: ConflictError
* else code matches "does not exist|not found"
* parseError->>ErrorTypes: new NotFoundError(code)
* ErrorTypes-->>Caller: NotFoundError
* end
* else err has code property
* Note over parseError: Extract code and reason
* else
* Note over parseError: Use err.message as code
* end
*
* Note over parseError: Switch on PostgreSQL error code
* alt code is 23505 (unique_violation)
* parseError->>ErrorTypes: new ConflictError(reason)
* ErrorTypes-->>Caller: ConflictError
* else code is 23503 (foreign_key_violation)
* parseError->>ErrorTypes: new ConflictError(reason)
* ErrorTypes-->>Caller: ConflictError
* else code is 42P01 (undefined_table)
* parseError->>ErrorTypes: new NotFoundError(reason)
* ErrorTypes-->>Caller: NotFoundError
* else code is 42703 (undefined_column)
* parseError->>ErrorTypes: new NotFoundError(reason)
* ErrorTypes-->>Caller: NotFoundError
* else code is 42P07 (duplicate_table)
* parseError->>ErrorTypes: new ConflictError(reason)
* ErrorTypes-->>Caller: ConflictError
* else code is 42P16 (invalid_table_definition)
* parseError->>ErrorTypes: new IndexError(err)
* ErrorTypes-->>Caller: IndexError
* else code matches "ECONNREFUSED"
* parseError->>ErrorTypes: new ConnectionError(err)
* ErrorTypes-->>Caller: ConnectionError
* else
* parseError->>ErrorTypes: new InternalError(err)
* ErrorTypes-->>Caller: InternalError
* end
*/
static parseError(err, reason) {
if (err instanceof db_decorators_1.BaseError)
return err;
const code = typeof err === "string" ? err : err.message;
if (code.match(/duplicate key|already exists/g))
return new db_decorators_1.ConflictError(code);
if (code.match(/does not exist|not found/g))
return new db_decorators_1.NotFoundError(code);
// PostgreSQL error codes: https://www.postgresql.org/docs/current/errcodes-appendix.html
switch (code.toString()) {
// Integrity constraint violations
case "23505": // unique_violation
case "23503": // foreign_key_violation
case "42P07": // duplicate_table
return new db_decorators_1.ConflictError(reason);
// Object not found errors
case "42P01": // undefined_table
case "42703": // undefined_column
return new db_decorators_1.NotFoundError(reason);
// Invalid object definition
case "42P16": // invalid_table_definition
return new errors_1.IndexError(err);
// Connection errors
default:
if (code.toString().match(/ECONNREFUSED/g))
return new core_1.ConnectionError(err);
return new db_decorators_1.InternalError(err);
}
}
static async connect(config) {
return new pg_1.Pool(config);
}
static async createDatabase(pool, dbName) {
const log = logging_1.Logging.for(this.createDatabase);
log.verbose(`Creating database ${dbName}`);
const client = await pool.connect();
try {
await client.query({
name: `create-database`,
text: `CREATE DATABASE ${dbName}`,
});
log.info(`Created database ${dbName}`);
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static async createNotifyFunction(pool, user) {
const log = logging_1.Logging.for(this.createNotifyFunction);
log.verbose(`Creating notify function`);
const client = await pool.connect();
try {
await client.query(`CREATE OR REPLACE FUNCTION notify_table_changes()
RETURNS trigger AS $$
BEGIN
PERFORM pg_notify(
'table_changes',
json_build_object(
'table', TG_TABLE_NAME,
'action', TG_OP,
'data', row_to_json(NEW),
'old_data', row_to_json(OLD)
)::text
);
RETURN NEW;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER
;`);
await client.query(`ALTER FUNCTION notify_table_changes() OWNER TO ${user};`);
await client.query(`
GRANT EXECUTE ON FUNCTION notify_table_changes() TO public;
`);
log.info(`Created notify function`);
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static async deleteDatabase(pool, dbName, user) {
const client = await pool.connect();
try {
if (user)
await client.query({
name: `delete-owned-by`,
text: `DROP OWNED BY ${user} CASCADE;`,
});
await client.query({
name: `delete-database`,
text: `DROP DATABASE ${dbName}`,
});
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static async createUser(pool, dbName, user, password) {
const client = await pool.connect();
try {
await client.query(`CREATE USER ${user} WITH PASSWORD '${password}'`);
await client.query(`GRANT CONNECT ON DATABASE ${dbName} TO ${user}`);
await client.query(`GRANT USAGE ON SCHEMA public TO ${user}`);
await client.query(`GRANT CREATE ON SCHEMA public TO ${user}`);
await client.query(`GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO ${user}`);
await client.query(`GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO ${user}`);
await client.query(`GRANT ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public TO ${user}`);
await client.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON TABLES TO ${user}`);
await client.query(`ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL PRIVILEGES ON SEQUENCES TO ${user}`);
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static async deleteUser(pool, user, admin) {
const client = await pool.connect();
try {
await client.query(`REASSIGN OWNED BY ${user} TO ${admin}`);
await client.query(`REVOKE ALL ON ALL TABLES IN SCHEMA public FROM ${user}`);
await client.query(`REVOKE ALL ON SCHEMA public FROM ${user}`);
await client.query(`REVOKE ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public FROM ${user}`);
await client.query(`REVOKE ALL PRIVILEGES ON ALL FUNCTIONS IN SCHEMA public FROM ${user}`);
await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON TABLES FROM ${user}`);
await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON SEQUENCES FROM ${user};`);
await client.query(`ALTER DEFAULT PRIVILEGES FOR ROLE ${admin} IN SCHEMA public REVOKE ALL ON FUNCTIONS FROM ${user}`);
await client.query(`DROP OWNED BY ${user} CASCADE`);
await client.query(`DROP USER IF EXISTS "${user}"`);
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static parseTypeToPostgres(type, isPk, isFk = false) {
switch (type.toLowerCase()) {
case "string":
return isPk ? "TEXT PRIMARY KEY" : isFk ? "TEXT" : "VARCHAR";
case "number":
return isPk ? "SERIAL PRIMARY KEY" : "INTEGER";
case "boolean":
return "BOOLEAN";
case "date":
return "TIMESTAMP";
case "bigint":
return isPk ? "BIGINT PRIMARY KEY" : "BIGINT";
default: {
const m = decorator_validation_1.Model.get(type);
if (m) {
const mm = new m();
const type = reflection_1.Reflection.getTypeFromDecorator(mm, (0, db_decorators_1.findPrimaryKey)(mm).id);
return {
model: m,
pkType: type,
};
}
throw new db_decorators_1.InternalError(`Unsupported type: ${type}`);
}
}
}
static parseValidationToPostgres(prop, type, isPk, key, options) {
switch (key) {
case decorator_validation_1.ValidationKeys.REQUIRED:
return "NOT NULL";
case decorator_validation_1.ValidationKeys.MAX_LENGTH:
if (isPk || !options || type.toLowerCase() !== "string") {
return "";
}
return `(${options[decorator_validation_1.ValidationKeys.MAX_LENGTH]})`;
case decorator_validation_1.ValidationKeys.MIN_LENGTH:
return `CONSTRAINT ${prop}_min_length_check CHECK (LENGTH(${prop}) >= ${options[decorator_validation_1.ValidationKeys.MIN_LENGTH]})`;
case decorator_validation_1.ValidationKeys.PATTERN:
case decorator_validation_1.ValidationKeys.URL:
case decorator_validation_1.ValidationKeys.EMAIL:
return `CONSTRAINT ${prop}_pattern_check CHECK (${prop} ~ '${(0, utils_1.convertJsRegexToPostgres)(options[decorator_validation_1.ValidationKeys.PATTERN])}')`;
case decorator_validation_1.ValidationKeys.TYPE:
case decorator_validation_1.ValidationKeys.DATE:
return "";
case decorator_validation_1.ValidationKeys.MIN:
return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} >= ${options[decorator_validation_1.ValidationKeys.MIN]})`;
case decorator_validation_1.ValidationKeys.MAX:
return `CONSTRAINT ${prop}_${key}_check CHECK (${prop} <= ${options[decorator_validation_1.ValidationKeys.MAX]})`;
case decorator_validation_1.ValidationKeys.PASSWORD:
default:
throw new db_decorators_1.InternalError(`Unsupported type: ${key}`);
}
}
static parseRelationsToPostgres(prop, clazz, pk, key, options) {
const tableName = core_1.Repository.table(clazz);
const { cascade } = options;
const cascadeStr = `${cascade.update ? " ON UPDATE CASCADE" : ""}${cascade.delete ? " ON DELETE CASCADE" : ""}`;
switch (`relations${key}`) {
case core_1.PersistenceKeys.ONE_TO_ONE:
return `FOREIGN KEY (${prop}) REFERENCES ${tableName}(${pk})${cascadeStr}`;
default:
throw new db_decorators_1.InternalError(`Unsupported operation: ${key}`);
}
}
static async createTable(pool, model) {
const result = {};
const m = new model();
const tableName = core_1.Repository.table(model);
const { id } = (0, db_decorators_1.findPrimaryKey)(m);
let isPk, column;
const properties = Object.getOwnPropertyNames(m);
for (const prop of properties) {
if (typeof this[prop] === "function" ||
prop.toString().startsWith("_") ||
prop === "constructor") {
continue;
}
isPk = prop === id;
column = core_1.Repository.column(m, prop.toString());
const allDecs = reflection_1.Reflection.getPropertyDecorators(decorator_validation_1.ValidationKeys.REFLECT, m, prop.toString(), false, true);
const decoratorData = allDecs.decorators.reduce((accum, el) => {
const { key, props } = el;
if (key === decorator_validation_1.ModelKeys.TYPE && !accum[decorator_validation_1.ValidationKeys.TYPE]) {
accum[decorator_validation_1.ValidationKeys.TYPE] = {
customTypes: [props.name],
message: decorator_validation_1.DEFAULT_ERROR_MESSAGES.TYPE,
description: "defines the accepted types for the attribute",
};
}
else if (key !== decorator_validation_1.ValidationKeys.TYPE) {
// do nothing. we can only support basis ctypes at this time
accum[key] = props;
}
return accum;
}, {});
const dbDecs = reflection_1.Reflection.getPropertyDecorators(core_1.Repository.key("relations"), m, prop.toString(), true, true);
const query = [];
const constraints = [];
const foreignKeys = [];
let typeData = undefined;
let childClass = undefined;
let childPk;
if (Object.keys(decoratorData).length) {
typeData = decoratorData[decorator_validation_1.ValidationKeys.TYPE];
if (!typeData) {
throw new Error(`Missing type information`);
}
let parsedType = this.parseTypeToPostgres(typeData.customTypes[0], isPk);
if (typeof parsedType === "string") {
parsedType = { model: parsedType };
}
let typeStr = parsedType.model;
if (typeof typeStr !== "string") {
if (Array.isArray(typeStr)) {
console.log(typeStr);
}
// continue;
// const res: Record<string, PostgresTableSpec> = await this.createTable(pool, typeStr);
try {
childClass = parsedType.model;
const m = new childClass();
childPk = (0, db_decorators_1.findPrimaryKey)(m);
typeStr = this.parseTypeToPostgres(parsedType.pkType, false, true);
await this.createTable(pool, childClass);
}
catch (e) {
throw new db_decorators_1.InternalError(`Error creating table for ${typeStr}: ${e}`);
}
// const tbl = Repository.table(typeStr);
// foreignKeys.push(`FOREIGN KEY (${prop as string}) REFERENCES ${tbl}(${pk as string})`);
}
const validationStr = this.parseValidationToPostgres(column, typeData.customTypes[0], isPk, decorator_validation_1.ValidationKeys.MAX_LENGTH, decoratorData[decorator_validation_1.ValidationKeys.MAX_LENGTH] || {
[decorator_validation_1.ValidationKeys.MAX_LENGTH]: 255,
});
const q = `${column} ${typeStr}${validationStr}`;
if (isPk) {
query.unshift(q);
}
else {
query.push(q);
}
for (const [key, props] of Object.entries(decoratorData).filter(([k]) => ![decorator_validation_1.ValidationKeys.TYPE, decorator_validation_1.ValidationKeys.MAX_LENGTH].includes(k))) {
const validation = this.parseValidationToPostgres(column, typeData.customTypes[0], isPk, key, props);
if (validation.startsWith("CONSTRAINT")) {
constraints.push(validation);
}
else {
if (validation) {
query.push(validation);
}
}
}
}
if (dbDecs && dbDecs.decorators.length) {
if (!typeData)
throw new Error(`Missing type information`);
for (const decorator of dbDecs.decorators) {
const { key, props } = decorator;
const validation = this.parseRelationsToPostgres(column, childClass, childPk.id, key, props);
if (validation.startsWith("FOREIGN")) {
foreignKeys.push(validation);
}
else {
throw new db_decorators_1.InternalError(`Unsupported relation: ${key}`);
}
}
}
result[prop.toString()] = {
query: query.join(" "),
values: [],
primaryKey: isPk,
constraints: constraints,
foreignKeys: foreignKeys,
};
}
const client = await pool.connect();
const values = Object.values(result);
const query = values.map((r) => r.query).join(",\n");
const constraints = values
.filter((c) => !!c.constraints.length)
.map((r) => r.constraints)
.join(",\n");
const foreignKeys = values
.filter((c) => !!c.foreignKeys.length)
.map((r) => r.foreignKeys)
.join(",\n");
const vals = [query, constraints];
if (foreignKeys) {
vals.push(foreignKeys);
}
const queryString = `CREATE TABLE ${tableName} (${vals.filter((v) => !!v).join(",\n")})`;
try {
await client.query(queryString);
await client.query(`CREATE TRIGGER notify_changes_${tableName}
AFTER INSERT OR UPDATE OR DELETE ON ${tableName}
FOR EACH ROW
EXECUTE FUNCTION notify_table_changes();`);
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
return result;
}
static async getCurrentUser(pool) {
const client = await pool.connect();
const queryString = `SELECT CURRENT_USER;`;
try {
const result = await client.query({
name: `get-current-user`,
text: queryString,
});
return result.rows[0].current_user;
}
catch (e) {
throw this.parseError(e);
}
finally {
client.release();
}
}
static decoration() {
const createdByKey = core_1.Repository.key(core_1.PersistenceKeys.CREATED_BY);
const updatedByKey = core_1.Repository.key(core_1.PersistenceKeys.UPDATED_BY);
const pkKey = core_1.Repository.key(db_decorators_1.DBKeys.ID);
const uniqueKey = core_1.Repository.key(db_decorators_1.DBKeys.UNIQUE);
decorator_validation_1.Decoration.flavouredAs(constants_1.PostgresFlavour)
.for(pkKey)
.define((0, decorator_validation_1.required)(), (0, db_decorators_1.readonly)(), (0, decorator_validation_1.propMetadata)(pkKey, core_1.DefaultSequenceOptions))
.apply();
decorator_validation_1.Decoration.flavouredAs(constants_1.PostgresFlavour)
.for(uniqueKey)
.define((0, decorator_validation_1.propMetadata)(uniqueKey, {}))
.apply();
decorator_validation_1.Decoration.flavouredAs(constants_1.PostgresFlavour)
.for(createdByKey)
.define((0, db_decorators_1.onCreate)(createdByOnPostgresCreateUpdate), (0, decorator_validation_1.propMetadata)(createdByKey, {}))
.apply();
decorator_validation_1.Decoration.flavouredAs(constants_1.PostgresFlavour)
.for(updatedByKey)
.define((0, db_decorators_1.onCreate)(createdByOnPostgresCreateUpdate), (0, decorator_validation_1.propMetadata)(updatedByKey, {}))
.apply();
}
}
exports.PostgresAdapter = PostgresAdapter;
__decorate([
(0, core_1.final)(),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", query_1.PostgresStatement)
], PostgresAdapter.prototype, "Statement", null);
__decorate([
(0, core_1.final)(),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", Promise)
], PostgresAdapter.prototype, "Sequence", null);
__decorate([
(0, core_1.final)(),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", Promise)
], PostgresAdapter.prototype, "index", null);
__decorate([
(0, core_1.final)(),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object, Boolean]),
__metadata("design:returntype", Promise)
], PostgresAdapter.prototype, "raw", null);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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