@restura/core 0.1.0-alpha.13 → 0.1.0-alpha.15

package/dist/index.js

@@ -68,7 +68,9 @@ 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,
@@ -258,7 +260,7 @@ var import_crypto = require("crypto");
 var express = __toESM(require("express"));
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
-var import_pg2 = __toESM(require("pg"));
+var import_pg4 = __toESM(require("pg"));
 var prettier3 = __toESM(require("prettier"));
 
 // src/restura/sql/SqlUtils.ts
@@ -790,7 +792,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({
@@ -876,6 +878,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.
@@ -938,6 +946,7 @@ var columnDataSchema = import_zod3.z.object({
     postgresColumnNumericTypesSchema,
     postgresColumnStringTypesSchema,
     postgresColumnDateTypesSchema,
+    postgresColumnJsonTypesSchema,
     mariaDbColumnNumericTypesSchema,
     mariaDbColumnStringTypesSchema,
     mariaDbColumnDateTypesSchema
@@ -1245,9 +1254,14 @@ 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
@@ -1297,25 +1311,16 @@ function SQL(strings, ...values) {
   return query;
 }
 
-// src/restura/sql/PsqlPool.ts
-var { Pool } = import_pg.default;
-var PsqlPool = class {
-  constructor(poolConfig) {
-    this.poolConfig = poolConfig;
-    this.pool = new Pool(poolConfig);
-    this.queryOne("SELECT NOW();", [], { isSystemUser: true, role: "", host: "localhost", ipAddress: "" }).then(() => {
-      logger.info("Connected to PostgreSQL database");
-    }).catch((error) => {
-      logger.error("Error connecting to database", error);
-      process.exit(1);
-    });
+// src/restura/sql/PsqlConnection.ts
+var PsqlConnection = class {
+  constructor() {
   }
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
   async queryOne(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
     try {
-      const response = await this.pool.query(formattedQuery, options);
+      const response = await this.query(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];
@@ -1332,10 +1337,8 @@ var PsqlPool = class {
   async runQuery(query, options, requesterDetails) {
     const formattedQuery = questionMarksToOrderedParams(query);
     this.logSqlStatement(formattedQuery, options, requesterDetails);
-    const queryUpdated = query.replace(/[\t\n]/g, " ");
-    console.log(queryUpdated, options);
     try {
-      const response = await this.pool.query(formattedQuery, options);
+      const response = await this.query(formattedQuery, options);
       return response.rows;
     } catch (error) {
       console.error(error, query, options);
@@ -1367,6 +1370,25 @@ var PsqlPool = class {
   }
 };
 
+// src/restura/sql/PsqlPool.ts
+var { Pool } = import_pg.default;
+var PsqlPool = class extends PsqlConnection {
+  constructor(poolConfig) {
+    super();
+    this.poolConfig = poolConfig;
+    this.pool = new Pool(poolConfig);
+    this.queryOne("SELECT NOW();", [], { isSystemUser: true, role: "", host: "localhost", ipAddress: "" }).then(() => {
+      logger.info("Connected to PostgreSQL database");
+    }).catch((error) => {
+      logger.error("Error connecting to database", error);
+      process.exit(1);
+    });
+  }
+  async query(query, values) {
+    return this.pool.query(query, values);
+  }
+};
+
 // src/restura/sql/SqlEngine.ts
 var import_core_utils4 = require("@redskytech/core-utils");
 var SqlEngine = class {
@@ -1531,9 +1553,9 @@ expressionList =
 
 expression = 
     negate:negate?"(" "column:" column:column ","? value:value? ","? type:type? ")" 
-    {return \`\${negate? "!" : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
+    {return \`\${negate? " NOT " : ""}(\${type?  type(column, value) : \`\${column} = \${format.literal(value)}\`})\`;}
     /
-    negate:negate?"("expression:expressionList")" { return \`\${negate? "!" : ""}(\${expression})\`; }
+    negate:negate?"("expression:expressionList")" { return \`\${negate? " NOT " : ""}(\${expression})\`; }
 
 negate = "!"
     
@@ -1568,9 +1590,7 @@ var filterPsqlParser = import_pegjs.default.generate(filterSqlGrammar, {
 var filterPsqlParser_default = filterPsqlParser;
 
 // 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: "",
@@ -1618,7 +1638,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");
@@ -1705,15 +1725,12 @@ 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);
-    console.log("Schema differences:", diff);
     await originalClient.end();
     await scratchClient.end();
     return diff.join("\n");
@@ -1990,16 +2007,135 @@ var PsqlEngine = class extends SqlEngine {
     return whereClause;
   }
 };
-var schemaToPsqlType = (column, tableName) => {
+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_pg3 = __toESM(require("pg"));
+var { Client: Client2 } = import_pg3.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) {
+    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);
+    const customTypes = newSchema.customTypes !== latestSchema.customTypes;
+    const schemaPreview = { endPoints, globalParams, roles, commands, customTypes };
+    return schemaPreview;
+  }
+  diffStringArray(newArray, originalArray) {
+    const stringsDiff = [];
+    const originalClone = new Set(originalArray);
+    newArray.forEach((item) => {
+      const originalIndex = originalClone.has(item);
+      if (!originalIndex) {
+        stringsDiff.push({
+          name: item,
+          changeType: "NEW"
+        });
+      } else {
+        originalClone.delete(item);
+      }
+    });
+    originalClone.forEach((item) => {
+      stringsDiff.push({
+        name: item,
+        changeType: "DELETED"
+      });
+    });
+    return stringsDiff;
+  }
+  diffEndPoints(newEndPoints, originalEndpoints) {
+    const originalClone = (0, import_lodash.default)(originalEndpoints);
+    const diffObj = [];
+    newEndPoints.forEach((endPoint) => {
+      const { path: path4, method } = endPoint;
+      const endPointIndex = originalClone.findIndex((original) => {
+        return original.path === endPoint.path && original.method === endPoint.method;
+      });
+      if (endPointIndex === -1) {
+        diffObj.push({
+          name: `${method} ${path4}`,
+          changeType: "NEW"
+        });
+      } else {
+        const original = originalClone.findIndex((original2) => {
+          return this.compareEndPoints(endPoint, original2);
+        });
+        if (original === -1) {
+          diffObj.push({
+            name: `${method} ${path4}`,
+            changeType: "MODIFIED"
+          });
+        }
+        originalClone.splice(endPointIndex, 1);
+      }
+    });
+    originalClone.forEach((original) => {
+      const { path: path4, method } = original;
+      diffObj.push({
+        name: `${method} ${path4}`,
+        changeType: "DELETED"
+      });
+    });
+    return diffObj;
+  }
+  compareEndPoints(endPoint1, endPoint2) {
+    return JSON.stringify(endPoint1) === JSON.stringify(endPoint2);
+  }
 };
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffSchema", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffStringArray", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "diffEndPoints", 1);
+__decorateClass([
+  boundMethod
+], CompareSchema.prototype, "compareEndPoints", 1);
+var compareSchema = new CompareSchema();
+var compareSchema_default = compareSchema;
 
 // src/restura/restura.ts
-var { types } = import_pg2.default;
+var { types } = import_pg4.default;
 var ResturaEngine = class {
   constructor() {
     this.publicEndpoints = {
@@ -2203,7 +2339,7 @@ var ResturaEngine = class {
   }
   async previewCreateSchema(req, res) {
     try {
-      const schemaDiff = { commands: "", endPoints: [], globalParams: [], roles: [], customTypes: false };
+      const schemaDiff = await compareSchema_default.diffSchema(req.data, this.schema, this.psqlEngine);
       res.send({ data: schemaDiff });
     } catch (err) {
       res.status(400).send(err);
@@ -2377,7 +2513,9 @@ var restura = new ResturaEngine();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HtmlStatusCodes,
+  PsqlConnection,
   PsqlPool,
+  PsqlTransaction,
   RsError,
   SQL,
   escapeColumnName,