@restura/core 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/index.js

@@ -68,9 +68,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 var src_exports = {};
 __export(src_exports, {
   HtmlStatusCodes: () => HtmlStatusCodes,
-  PsqlConnection: () => PsqlConnection,
   PsqlPool: () => PsqlPool,
-  PsqlTransaction: () => PsqlTransaction,
   RsError: () => RsError,
   SQL: () => SQL,
   escapeColumnName: () => escapeColumnName,
@@ -792,7 +790,7 @@ var joinDataSchema = import_zod3.z.object({
 var requestDataSchema = import_zod3.z.object({
   name: import_zod3.z.string(),
   required: import_zod3.z.boolean(),
-  isNullable: import_zod3.z.boolean().optional().default(false),
+  isNullable: import_zod3.z.boolean().optional(),
   validator: import_zod3.z.array(validatorDataSchema)
 }).strict();
 var responseDataSchema = import_zod3.z.object({
@@ -878,6 +876,12 @@ var postgresColumnDateTypesSchema = import_zod3.z.enum([
   "INTERVAL"
   // time span
 ]);
+var postgresColumnJsonTypesSchema = import_zod3.z.enum([
+  "JSON",
+  // stores JSON data as raw text
+  "JSONB"
+  // stores JSON data in a binary format, optimized for query performance
+]);
 var mariaDbColumnNumericTypesSchema = import_zod3.z.enum([
   "BOOLEAN",
   // 1-byte A synonym for "TINYINT(1)". Supported from version 1.2.0 onwards.
@@ -940,6 +944,7 @@ var columnDataSchema = import_zod3.z.object({
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
+    postgresColumnJsonTypesSchema,
     mariaDbColumnNumericTypesSchema,
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
@@ -1247,10 +1252,16 @@ function convertTable(table) {
 
 // src/restura/sql/PsqlEngine.ts
 var import_core_utils5 = require("@redskytech/core-utils");
+var import_pg_diff_sync = __toESM(require("@wmfs/pg-diff-sync"));
+var import_pg_info = __toESM(require("@wmfs/pg-info"));
+var import_pg2 = __toESM(require("pg"));
 
 // src/restura/sql/PsqlPool.ts
 var import_pg = __toESM(require("pg"));
 
+// src/restura/sql/PsqlConnection.ts
+var import_pg_format2 = __toESM(require("pg-format"));
+
 // src/restura/sql/PsqlUtils.ts
 var import_pg_format = __toESM(require("pg-format"));
 function escapeColumnName(columnName) {
@@ -1266,7 +1277,8 @@ function insertObjectQuery(table, obj) {
   const params = Object.values(obj);
   const columns = keys.map((column) => escapeColumnName(column)).join(", ");
   const values = params.map((value) => SQL`${value}`).join(", ");
-  const query = `INSERT INTO "${table}" (${columns})
+  const query = `
+INSERT INTO "${table}" (${columns})
                  VALUES (${values})
                  RETURNING *`;
   return query;
@@ -1276,7 +1288,8 @@ function updateObjectQuery(table, obj, whereStatement) {
   for (const i in obj) {
     setArray.push(`${escapeColumnName(i)} = ` + SQL`${obj[i]}`);
   }
-  return `UPDATE ${escapeColumnName(table)}
+  return `
+UPDATE ${escapeColumnName(table)}
                  SET ${setArray.join(", ")} ${whereStatement}
                  RETURNING *`;
 }
@@ -1299,7 +1312,6 @@ function SQL(strings, ...values) {
 }
 
 // src/restura/sql/PsqlConnection.ts
-var import_pg_format2 = __toESM(require("pg-format"));
 var PsqlConnection = class {
   constructor() {
   }
@@ -1307,8 +1319,10 @@ var PsqlConnection = class {
   async queryOne(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(requesterDetails)})
+`;
     try {
-      const response = await this.query(formattedQuery, options);
+      const response = await this.query(queryMetadata + formattedQuery, options);
       if (response.rows.length === 0) throw new RsError("NOT_FOUND", "No results found");
       else if (response.rows.length > 1) throw new RsError("DUPLICATE", "More than one result found");
       return response.rows[0];
@@ -1325,8 +1339,10 @@ var PsqlConnection = class {
   async runQuery(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
+    const queryMetadata = `--QUERY_METADATA(${JSON.stringify(requesterDetails)})
+`;
     try {
-      const response = await this.query(formattedQuery, options);
+      const response = await this.query(queryMetadata + formattedQuery, options);
       return response.rows;
     } catch (error) {
       console.error(error, query, options);
@@ -1577,10 +1593,112 @@ var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
 });
 var filterPsqlParser_default = filterPsqlParser;
 
+// src/restura/eventManager.ts
+var import_bluebird = __toESM(require("bluebird"));
+var EventManager = class {
+  constructor() {
+    this.actionHandlers = {
+      DATABASE_ROW_DELETE: [],
+      DATABASE_ROW_INSERT: [],
+      DATABASE_COLUMN_UPDATE: []
+    };
+  }
+  addRowInsertHandler(onInsert, filter) {
+    this.actionHandlers.DATABASE_ROW_INSERT.push({
+      callback: onInsert,
+      filter
+    });
+  }
+  addColumnChangeHandler(onUpdate, filter) {
+    this.actionHandlers.DATABASE_COLUMN_UPDATE.push({
+      callback: onUpdate,
+      filter
+    });
+  }
+  addRowDeleteHandler(onDelete, filter) {
+    this.actionHandlers.DATABASE_ROW_DELETE.push({
+      callback: onDelete,
+      filter
+    });
+  }
+  async fireActionFromDbTrigger(sqlMutationData, result) {
+    if (sqlMutationData.mutationType === "INSERT") {
+      await this.fireInsertActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "UPDATE") {
+      await this.fireUpdateActions(sqlMutationData, result);
+    } else if (sqlMutationData.mutationType === "DELETE") {
+      await this.fireDeleteActions(sqlMutationData, result);
+    }
+  }
+  async fireInsertActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_INSERT,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
+        const insertData = {
+          tableName: triggerResult.table,
+          insertId: triggerResult.record.id,
+          insertObject: triggerResult.record,
+          requesterDetails: data.requesterDetails
+        };
+        callback(insertData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireDeleteActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_ROW_DELETE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
+        const deleteData = {
+          tableName: triggerResult.table,
+          deletedRow: triggerResult.previousRecord,
+          requesterDetails: data.requesterDetails
+        };
+        callback(deleteData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  async fireUpdateActions(data, triggerResult) {
+    await import_bluebird.default.map(
+      this.actionHandlers.DATABASE_COLUMN_UPDATE,
+      ({ callback, filter }) => {
+        if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
+        const columnChangeData = {
+          tableName: triggerResult.table,
+          rowId: triggerResult.record.id,
+          newData: triggerResult.record,
+          oldData: triggerResult.previousRecord,
+          requesterDetails: data.requesterDetails
+        };
+        callback(columnChangeData, data.requesterDetails);
+      },
+      { concurrency: 10 }
+    );
+  }
+  hasHandlersForEventType(eventType, filter, triggerResult) {
+    if (filter) {
+      switch (eventType) {
+        case "DATABASE_ROW_INSERT":
+        case "DATABASE_ROW_DELETE":
+          if (filter.tableName && filter.tableName !== triggerResult.table) return false;
+          break;
+        case "DATABASE_COLUMN_UPDATE":
+          const filterColumnChange = filter;
+          if (filterColumnChange.tableName !== filter.tableName) return false;
+          break;
+      }
+    }
+    return true;
+  }
+};
+var eventManager = new EventManager();
+var eventManager_default = eventManager;
+
 // src/restura/sql/PsqlEngine.ts
-var import_pg_diff_sync = __toESM(require("@wmfs/pg-diff-sync"));
-var import_pg_info = __toESM(require("@wmfs/pg-info"));
-var { Client } = "pg";
+var { Client } = import_pg2.default;
 var systemUser = {
   role: "",
   host: "",
@@ -1588,9 +1706,49 @@ var systemUser = {
   isSystemUser: true
 };
 var PsqlEngine = class extends SqlEngine {
-  constructor(psqlConnectionPool) {
+  constructor(psqlConnectionPool, shouldListenForDbTriggers = false) {
     super();
     this.psqlConnectionPool = psqlConnectionPool;
+    if (shouldListenForDbTriggers) {
+      this.setupTriggerListeners = this.listenForDbTriggers();
+    }
+  }
+  async close() {
+    if (this.triggerClient) {
+      await this.triggerClient.end();
+    }
+  }
+  async listenForDbTriggers() {
+    this.triggerClient = new Client({
+      user: this.psqlConnectionPool.poolConfig.user,
+      host: this.psqlConnectionPool.poolConfig.host,
+      database: this.psqlConnectionPool.poolConfig.database,
+      password: this.psqlConnectionPool.poolConfig.password,
+      port: this.psqlConnectionPool.poolConfig.port,
+      connectionTimeoutMillis: 2e3
+    });
+    await this.triggerClient.connect();
+    const promises = [];
+    promises.push(this.triggerClient.query("LISTEN insert"));
+    promises.push(this.triggerClient.query("LISTEN update"));
+    promises.push(this.triggerClient.query("LISTEN delete"));
+    await Promise.all(promises);
+    this.triggerClient.on("notification", async (msg) => {
+      if (msg.channel === "insert" || msg.channel === "update" || msg.channel === "delete") {
+        const payload = JSON.parse(msg.payload);
+        await this.handleTrigger(payload, msg.channel.toUpperCase());
+      }
+    });
+  }
+  async handleTrigger(payload, mutationType) {
+    const findRequesterDetailsRegex = /^--QUERY_METADATA\(\{.*\}\)/;
+    let requesterDetails = {};
+    const match = payload.query.match(findRequesterDetailsRegex);
+    if (match) {
+      const jsonString = match[0].slice(match[0].indexOf("{"), match[0].lastIndexOf("}") + 1);
+      requesterDetails = import_core_utils5.ObjectUtils.safeParse(jsonString);
+      await eventManager_default.fireActionFromDbTrigger({ requesterDetails, mutationType }, payload);
+    }
   }
   async createDatabaseFromSchema(schema, connection) {
     const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
@@ -1601,7 +1759,11 @@ var PsqlEngine = class extends SqlEngine {
     const sqlStatements = [];
     const enums = [];
     const indexes = [];
+    const triggers = [];
     for (const table of schema.database) {
+      triggers.push(this.createInsertTriggers(table.name));
+      triggers.push(this.createUpdateTrigger(table.name));
+      triggers.push(this.createDeleteTrigger(table.name));
       let sql = `CREATE TABLE "${table.name}"
 					   ( `;
       const tableColumns = [];
@@ -1628,7 +1790,7 @@ var PsqlEngine = class extends SqlEngine {
         }
         if (column.isNullable) columnSql += " NULL";
         else columnSql += " NOT NULL";
-        if (column.default) columnSql += ` DEFAULT '${column.default}'`;
+        if (column.default) columnSql += ` DEFAULT ${column.default}`;
         tableColumns.push(columnSql);
       }
       sql += tableColumns.join(", \n");
@@ -1639,7 +1801,7 @@ var PsqlEngine = class extends SqlEngine {
           indexes.push(
             `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}" (${index.columns.map((item) => {
               return `"${item}" ${index.order}`;
-            }).join(", ")})`
+            }).join(", ")});`
           );
         }
       }
@@ -1669,7 +1831,8 @@ var PsqlEngine = class extends SqlEngine {
       }
       sqlStatements.push(sql + constraints.join(",\n") + ";");
     }
-    sqlStatements.push(indexes.join(";\n"));
+    sqlStatements.push(indexes.join("\n"));
+    sqlStatements.push(triggers.join("\n"));
     return enums.join("\n") + "\n" + sqlStatements.join("\n\n");
   }
   async getScratchPool() {
@@ -1715,12 +1878,10 @@ var PsqlEngine = class extends SqlEngine {
     await originalClient.connect();
     await scratchClient.connect();
     const info1 = await (0, import_pg_info.default)({
-      client: originalClient,
-      schema: "public"
+      client: originalClient
     });
     const info2 = await (0, import_pg_info.default)({
-      client: scratchClient,
-      schema: "public"
+      client: scratchClient
     });
     const diff = (0, import_pg_diff_sync.default)(info1, info2);
     await originalClient.end();
@@ -1739,8 +1900,7 @@ var PsqlEngine = class extends SqlEngine {
     )) {
       return "'[]'";
     }
-    return `COALESCE((
-				SELECT JSON_AGG(JSON_BUILD_OBJECT(
+    return `COALESCE((SELECT JSON_AGG(JSON_BUILD_OBJECT(
 			${item.subquery.properties.map((nestedItem) => {
       if (!this.doesRoleHavePermissionToColumn(req.requesterDetails.role, schema, nestedItem, [
         ...routeData.joins,
@@ -1749,7 +1909,7 @@ var PsqlEngine = class extends SqlEngine {
         return;
       }
       if (nestedItem.subquery) {
-        return `"${nestedItem.name}", ${this.createNestedSelect(
+        return `'${nestedItem.name}', ${this.createNestedSelect(
           // recursion
           req,
           schema,
@@ -1760,7 +1920,7 @@ var PsqlEngine = class extends SqlEngine {
         )}`;
       }
       return `'${nestedItem.name}', ${escapeColumnName(nestedItem.selector)}`;
-    }).filter(Boolean).join(",")}
+    }).filter(Boolean).join(", ")}
 						)) 
 						FROM
 							"${item.subquery.table}"
@@ -1888,10 +2048,12 @@ var PsqlEngine = class extends SqlEngine {
       req.requesterDetails.role,
       sqlParams
     );
-    let deleteStatement = `DELETE
-                           FROM "${routeData.table}" ${joinStatement}`;
-    deleteStatement += this.generateWhereClause(req, routeData.where, routeData, sqlParams);
-    deleteStatement += ";";
+    const whereClause = this.generateWhereClause(req, routeData.where, routeData, sqlParams);
+    if (whereClause.replace(/\s/g, "") === "") {
+      throw new RsError("DELETE_FORBIDDEN", "Deletes need a where clause");
+    }
+    const deleteStatement = `
+DELETE FROM "${routeData.table}" ${joinStatement} ${whereClause}`;
     await this.psqlConnectionPool.runQuery(deleteStatement, sqlParams, req.requesterDetails);
     return true;
   }
@@ -1954,17 +2116,17 @@ var PsqlEngine = class extends SqlEngine {
         );
       let operator = item.operator;
       if (operator === "LIKE") {
-        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}%`;
+        item.value = `%${item.value}%`;
       } else if (operator === "STARTS WITH") {
         operator = "LIKE";
-        sqlParams[sqlParams.length - 1] = `${sqlParams[sqlParams.length - 1]}%`;
+        item.value = `${item.value}%`;
       } else if (operator === "ENDS WITH") {
         operator = "LIKE";
-        sqlParams[sqlParams.length - 1] = `%${sqlParams[sqlParams.length - 1]}`;
+        item.value = `%${item.value}`;
       }
       const replacedValue = this.replaceParamKeywords(item.value, routeData, req, sqlParams);
       const escapedValue = SQL`${replacedValue}`;
-      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator} ${["IN", "NOT IN"].includes(operator) ? `(${escapedValue})` : escapedValue}
+      whereClause += `	${item.conjunction || ""} "${item.tableName}"."${item.columnName}" ${operator.replace("LIKE", "ILIKE")} ${["IN", "NOT IN"].includes(operator) ? `(${escapedValue})` : escapedValue}
 `;
     });
     const data = req.data;
@@ -1998,63 +2160,94 @@ var PsqlEngine = class extends SqlEngine {
     }
     return whereClause;
   }
+  createUpdateTrigger(tableName) {
+    return ` 
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('update', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER ${tableName}_update
+    AFTER UPDATE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+		`;
+  }
+  createDeleteTrigger(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('delete', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_delete"
+    AFTER DELETE ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_delete();
+		`;
+  }
+  createInsertTriggers(tableName) {
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+    RETURNS TRIGGER AS $$
+BEGIN
+    PERFORM pg_notify('insert', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER "${tableName}_insert"
+    AFTER INSERT ON "${tableName}"
+    FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+		`;
+  }
 };
-var schemaToPsqlType = (column, tableName) => {
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "handleTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createUpdateTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createDeleteTrigger", 1);
+__decorateClass([
+  boundMethod
+], PsqlEngine.prototype, "createInsertTriggers", 1);
+function schemaToPsqlType(column, tableName) {
   if (column.hasAutoIncrement) return "BIGSERIAL";
   if (column.type === "ENUM") return `"${tableName}_${column.name}_enum"`;
   if (column.type === "DATETIME") return "TIMESTAMPTZ";
   if (column.type === "MEDIUMINT") return "INT";
   return column.type;
-};
-
-// src/restura/sql/PsqlTransaction.ts
-var import_pg2 = __toESM(require("pg"));
-var { Client: Client2 } = import_pg2.default;
-var PsqlTransaction = class extends PsqlConnection {
-  constructor(clientConfig) {
-    super();
-    this.clientConfig = clientConfig;
-    this.client = new Client2(clientConfig);
-    this.beginTransactionPromise = this.beginTransaction();
-  }
-  async beginTransaction() {
-    return this.query("BEGIN");
-  }
-  async rollback() {
-    return this.query("ROLLBACK");
-  }
-  async commit() {
-    return this.query("COMMIT");
-  }
-  async release() {
-    return this.client.end();
-  }
-  async query(query, values) {
-    await this.client.connect();
-    await this.beginTransactionPromise;
-    return this.client.query(query, values);
-  }
-};
+}
 
 // src/restura/compareSchema.ts
 var import_lodash = __toESM(require("lodash.clonedeep"));
 var CompareSchema = class {
   async diffSchema(newSchema, latestSchema, psqlEngine) {
-    let endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
-    let globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
-    let roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
+    const endPoints = this.diffEndPoints(newSchema.endpoints[0].routes, latestSchema.endpoints[0].routes);
+    const globalParams = this.diffStringArray(newSchema.globalParams, latestSchema.globalParams);
+    const roles = this.diffStringArray(newSchema.roles, latestSchema.roles);
     let commands = "";
     if (JSON.stringify(newSchema.database) !== JSON.stringify(latestSchema.database))
       commands = await psqlEngine.diffDatabaseToSchema(newSchema);
-    let customTypes = newSchema.customTypes !== latestSchema.customTypes;
+    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
     const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
     return schemaPreview;
   }
   diffStringArray(newArray, originalArray) {
-    let stringsDiff = [];
-    let originalClone = new Set(originalArray);
+    const stringsDiff = [];
+    const originalClone = new Set(originalArray);
     newArray.forEach((item) => {
-      let originalIndex = originalClone.has(item);
+      const originalIndex = originalClone.has(item);
       if (!originalIndex) {
         stringsDiff.push({
           name: item,
@@ -2073,11 +2266,11 @@ var CompareSchema = class {
     return stringsDiff;
   }
   diffEndPoints(newEndPoints, originalEndpoints) {
-    let originalClone = (0, import_lodash.default)(originalEndpoints);
-    let diffObj = [];
+    const originalClone = (0, import_lodash.default)(originalEndpoints);
+    const diffObj = [];
     newEndPoints.forEach((endPoint) => {
-      let { path: path4, method } = endPoint;
-      let endPointIndex = originalClone.findIndex((original) => {
+      const { path: path4, method } = endPoint;
+      const endPointIndex = originalClone.findIndex((original) => {
         return original.path === endPoint.path && original.method === endPoint.method;
       });
       if (endPointIndex === -1) {
@@ -2086,7 +2279,7 @@ var CompareSchema = class {
           changeType: "NEW"
         });
       } else {
-        let original = originalClone.findIndex((original2) => {
+        const original = originalClone.findIndex((original2) => {
           return this.compareEndPoints(endPoint, original2);
         });
         if (original === -1) {
@@ -2099,7 +2292,7 @@ var CompareSchema = class {
       }
     });
     originalClone.forEach((original) => {
-      let { path: path4, method } = original;
+      const { path: path4, method } = original;
       diffObj.push({
         name: `${method} ${path4}`,
         changeType: "DELETED"
@@ -2502,12 +2695,14 @@ var setupPgReturnTypes = () => {
 };
 setupPgReturnTypes();
 var restura = new ResturaEngine();
+
+// src/restura/sql/PsqlTransaction.ts
+var import_pg4 = __toESM(require("pg"));
+var { Client: Client2 } = import_pg4.default;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HtmlStatusCodes,
-  PsqlConnection,
   PsqlPool,
-  PsqlTransaction,
   RsError,
   SQL,
   escapeColumnName,