@restura/core 0.1.0-alpha.35 → 0.1.0-alpha.37

package/dist/index.mjs

@@ -129,7 +129,7 @@ var EventManager = class {
         if (!this.hasHandlersForEventType("DATABASE_ROW_INSERT", filter, triggerResult)) return;
         const insertData = {
           tableName: triggerResult.table,
-          insertId: triggerResult.record.id,
+          insertedId: triggerResult.insertedId || 0,
           insertObject: triggerResult.record,
           queryMetadata: data.queryMetadata
         };
@@ -145,6 +145,7 @@ var EventManager = class {
         if (!this.hasHandlersForEventType("DATABASE_ROW_DELETE", filter, triggerResult)) return;
         const deleteData = {
           tableName: triggerResult.table,
+          deletedId: triggerResult.deletedId || 0,
           deletedRow: triggerResult.previousRecord,
           queryMetadata: data.queryMetadata
         };
@@ -160,7 +161,7 @@ var EventManager = class {
         if (!this.hasHandlersForEventType("DATABASE_COLUMN_UPDATE", filter, triggerResult)) return;
         const columnChangeData = {
           tableName: triggerResult.table,
-          rowId: triggerResult.record.id,
+          changedId: triggerResult.changedId || 0,
           newData: triggerResult.record,
           oldData: triggerResult.previousRecord,
           queryMetadata: data.queryMetadata
@@ -504,7 +505,7 @@ var SqlUtils = class _SqlUtils {
   static convertDatabaseTypeToTypescript(type, value) {
     type = type.toLocaleLowerCase();
     if (type.startsWith("tinyint") || type.startsWith("boolean")) return "boolean";
-    if (type.indexOf("int") > -1 || type.startsWith("decimal") || type.startsWith("double") || type.startsWith("float"))
+    if (type.indexOf("int") > -1 || type.startsWith("decimal") || type.startsWith("double") || type.startsWith("float") || type.indexOf("serial") > -1 || type.startsWith("decimal") || type.startsWith("real") || type.startsWith("double precision") || type.startsWith("numeric"))
       return "number";
     if (type === "json") {
       if (!value) return "object";
@@ -786,21 +787,28 @@ var ApiTree = class _ApiTree {
         return `export type Res = CustomTypes.${route.responseType}[]`;
       else return `export type Res = CustomTypes.${route.responseType}`;
     }
-    return `export interface Res ${this.getFields(route.response)}`;
+    return `export interface Res ${this.getFields(route.response, route.table, route.joins)}`;
   }
-  getFields(fields) {
-    const nameFields = fields.map((f) => this.getNameAndType(f));
+  getFields(fields, routeBaseTable, joins) {
+    const nameFields = fields.map((f) => this.getNameAndType(f, routeBaseTable, joins));
     const nested = `{
 			${nameFields.join(";\n	")}${ObjectUtils.isArrayWithData(nameFields) ? ";" : ""}
 		}`;
     return nested;
   }
-  getNameAndType(p) {
+  getNameAndType(p, routeBaseTable, joins) {
     let responseType = "any", isNullable = false, array = false;
     if (p.selector) {
       ({ responseType, isNullable } = this.getTypeFromTable(p.selector, p.name));
+      const selectorKey = p.selector.split(".")[0];
+      if (selectorKey !== routeBaseTable) {
+        const join = joins.find((j) => j.alias === selectorKey);
+        if (join && join.type !== "INNER") {
+          isNullable = true;
+        }
+      }
     } else if (p.subquery) {
-      responseType = this.getFields(p.subquery.properties);
+      responseType = this.getFields(p.subquery.properties, p.subquery.table, p.subquery.joins);
       array = true;
     }
     return `${p.name}:${responseType}${array ? "[]" : ""}${isNullable ? " | null" : ""}`;
@@ -1266,7 +1274,8 @@ var tableDataSchema = z3.object({
   indexes: z3.array(indexDataSchema),
   foreignKeys: z3.array(foreignKeyDataSchema),
   checkConstraints: z3.array(checkConstraintDataSchema),
-  roles: z3.array(z3.string())
+  roles: z3.array(z3.string()),
+  notify: z3.union([z3.literal("ALL"), z3.array(z3.string())]).optional()
 }).strict();
 var endpointDataSchema = z3.object({
   name: z3.string(),
@@ -1560,10 +1569,11 @@ 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 = `
+  let query = `
 INSERT INTO "${table}" (${columns})
                  VALUES (${values})
                  RETURNING *`;
+  query = query.replace(/'(\?)'/, "?");
   return query;
 }
 function updateObjectQuery(table, obj, whereStatement) {
@@ -1939,16 +1949,8 @@ var PsqlEngine = class extends SqlEngine {
     });
   }
   async handleTrigger(payload, mutationType) {
-    const findRequesterDetailsRegex = /^--QUERY_METADATA\(\{.*\}\)/;
-    const match = payload.query.match(findRequesterDetailsRegex);
-    if (match) {
-      const jsonString = match[0].slice(match[0].indexOf("{"), match[0].lastIndexOf("}") + 1);
-      const queryMetadata = ObjectUtils4.safeParse(jsonString);
-      const triggerFromThisInstance = queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId;
-      if (!triggerFromThisInstance) {
-        return;
-      }
-      await eventManager_default.fireActionFromDbTrigger({ queryMetadata, mutationType }, payload);
+    if (payload.queryMetadata && payload.queryMetadata.connectionInstanceId === this.psqlConnectionPool.instanceId) {
+      await eventManager_default.fireActionFromDbTrigger({ queryMetadata: payload.queryMetadata, mutationType }, payload);
     }
   }
   async createDatabaseFromSchema(schema, connection) {
@@ -1961,9 +1963,11 @@ var PsqlEngine = class extends SqlEngine {
     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));
+      if (table.notify) {
+        triggers.push(this.createInsertTriggers(table.name, table.notify));
+        triggers.push(this.createUpdateTrigger(table.name, table.notify));
+        triggers.push(this.createDeleteTrigger(table.name, table.notify));
+      }
       let sql = `CREATE TABLE "${table.name}"
 					   ( `;
       const tableColumns = [];
@@ -2390,53 +2394,216 @@ DELETE FROM "${routeData.table}" ${joinStatement} ${whereClause}`;
     }
     return whereClause;
   }
-  createUpdateTrigger(tableName) {
-    return ` 
+  createUpdateTrigger(tableName, notify) {
+    if (!notify) return "";
+    if (notify === "ALL") {
+      return `
 CREATE OR REPLACE FUNCTION notify_${tableName}_update()
-    RETURNS TRIGGER AS $$
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
 BEGIN
-    PERFORM pg_notify('update', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
-    RETURN NEW;
+	SELECT INTO query_metadata
+				(regexp_match(
+						current_query(),
+						'^--QUERY_METADATA\\(({.*})', 'n'
+				))[1]::json;
+
+	PERFORM pg_notify(
+		'update',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'changedId', NEW.id,
+						'record', NEW, 
+						'previousRecord', OLD
+		)::text
+		);
+	RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE TRIGGER ${tableName}_update
-    AFTER UPDATE ON "${tableName}"
-    FOR EACH ROW
+	AFTER UPDATE ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_update();
+`;
+    }
+    const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
+    const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
+    return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_update()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+				(regexp_match(
+						current_query(),
+						'^--QUERY_METADATA\\(({.*})', 'n'
+				))[1]::json;
+
+	PERFORM pg_notify(
+		'update',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'changedId', NEW.id,
+						'record', json_build_object(
+							${notifyColumnNewBuildString}
+						),
+						'previousRecord', json_build_object(
+							${notifyColumnOldBuildString}
+						)
+		)::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) {
+  createDeleteTrigger(tableName, notify) {
+    if (!notify) return "";
+    if (notify === "ALL") {
+      return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'delete',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'deletedId', OLD.id,
+						'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();
+`;
+    }
+    const notifyColumnOldBuildString = notify.map((column) => `'${column}', OLD."${column}"`).join(",\n");
     return `
 CREATE OR REPLACE FUNCTION notify_${tableName}_delete()
-    RETURNS TRIGGER AS $$
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
 BEGIN
-    PERFORM pg_notify('delete', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
-    RETURN NEW;
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'delete',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'deletedId', OLD.id,
+						'previousRecord', json_build_object(
+							${notifyColumnOldBuildString}
+						)
+		)::text
+		);
+	RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
 CREATE OR REPLACE TRIGGER "${tableName}_delete"
-    AFTER DELETE ON "${tableName}"
-    FOR EACH ROW
+	AFTER DELETE ON "${tableName}"
+	FOR EACH ROW
 EXECUTE FUNCTION notify_${tableName}_delete();
 		`;
   }
-  createInsertTriggers(tableName) {
+  createInsertTriggers(tableName, notify) {
+    if (!notify) return "";
+    if (notify === "ALL") {
+      return `
+CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
+BEGIN
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', NEW
+		)::text
+		);
+
+	RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
+EXECUTE FUNCTION notify_${tableName}_insert();
+`;
+    }
+    const notifyColumnNewBuildString = notify.map((column) => `'${column}', NEW."${column}"`).join(",\n");
     return `
 CREATE OR REPLACE FUNCTION notify_${tableName}_insert()
-    RETURNS TRIGGER AS $$
+	RETURNS TRIGGER AS $$
+DECLARE
+	query_metadata JSON;
 BEGIN
-    PERFORM pg_notify('insert', JSON_BUILD_OBJECT('table', '${tableName}', 'query', current_query(), 'record', NEW, 'previousRecord', OLD)::text);
-    RETURN NEW;
+	SELECT INTO query_metadata
+			(regexp_match(
+					current_query(),
+					'^--QUERY_METADATA\\(({.*})', 'n'
+			))[1]::json;
+
+	PERFORM pg_notify(
+		'insert',
+		json_build_object(
+						'table', '${tableName}',
+						'queryMetadata', query_metadata,
+						'insertedId', NEW.id,
+						'record', json_build_object(
+							${notifyColumnNewBuildString}
+						)
+		)::text
+		);
+		
+	RETURN NEW;
 END;
 $$ LANGUAGE plpgsql;
 
-CREATE TRIGGER "${tableName}_insert"
-    AFTER INSERT ON "${tableName}"
-    FOR EACH ROW
+CREATE OR REPLACE TRIGGER "${tableName}_insert"
+	AFTER INSERT ON "${tableName}"
+	FOR EACH ROW
 EXECUTE FUNCTION notify_${tableName}_insert();
-		`;
+`;
   }
   schemaToPsqlType(column) {
     if (column.hasAutoIncrement) return "BIGSERIAL";
@@ -2446,15 +2613,6 @@ EXECUTE FUNCTION notify_${tableName}_insert();
     return column.type;
   }
 };
-__decorateClass([
-  boundMethod
-], PsqlEngine.prototype, "createUpdateTrigger", 1);
-__decorateClass([
-  boundMethod
-], PsqlEngine.prototype, "createDeleteTrigger", 1);
-__decorateClass([
-  boundMethod
-], PsqlEngine.prototype, "createInsertTriggers", 1);
 
 // src/restura/utils/TempCache.ts
 import fs3 from "fs";