@restura/core 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/index.js

@@ -258,7 +258,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_pg3 = __toESM(require("pg"));
 var prettier3 = __toESM(require("prettier"));
 
 // src/restura/sql/SqlUtils.ts
@@ -536,7 +536,7 @@ var ApiTree = class _ApiTree {
             break;
         }
       }
-      return `'${p.name}'${p.required ? "" : "?"}:${requestType}`;
+      return `'${p.name}'${p.required ? "" : "?"}:${requestType}${p.isNullable ? " | null" : ""}`;
     }).join(";\n")}${import_core_utils.ObjectUtils.isArrayWithData(route.request) ? ";" : ""}
 		 `;
     modelString += `}`;
@@ -560,18 +560,18 @@ var ApiTree = class _ApiTree {
     return nested;
   }
   getNameAndType(p) {
-    let responseType = "any", optional = false, array = false;
+    let responseType = "any", isNullable = false, array = false;
     if (p.selector) {
-      ({ responseType, optional } = this.getTypeFromTable(p.selector, p.name));
+      ({ responseType, isNullable } = this.getTypeFromTable(p.selector, p.name));
     } else if (p.subquery) {
       responseType = this.getFields(p.subquery.properties);
       array = true;
     }
-    return `${p.name}${optional ? "?" : ""}:${responseType}${array ? "[]" : ""}`;
+    return `${p.name}:${responseType}${array ? "[]" : ""}${isNullable ? " | null" : ""}`;
   }
   getTypeFromTable(selector, name) {
     const path4 = selector.split(".");
-    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { responseType: "any", optional: false };
+    if (path4.length === 0 || path4.length > 2 || path4[0] === "") return { responseType: "any", isNullable: false };
     let tableName = path4.length == 2 ? path4[0] : name;
     const columnName = path4.length == 2 ? path4[1] : path4[0];
     let table = this.database.find((t) => t.name == tableName);
@@ -581,10 +581,10 @@ var ApiTree = class _ApiTree {
       table = this.database.find((t) => t.name == tableName);
     }
     const column = table == null ? void 0 : table.columns.find((c) => c.name == columnName);
-    if (!table || !column) return { responseType: "any", optional: false };
+    if (!table || !column) return { responseType: "any", isNullable: false };
     return {
       responseType: SqlUtils.convertDatabaseTypeToTypescript(column.type, column.value),
-      optional: column.roles.length > 0 || column.isNullable
+      isNullable: column.roles.length > 0 || column.isNullable
     };
   }
 };
@@ -790,6 +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),
   validator: import_zod3.z.array(validatorDataSchema)
 }).strict();
 var responseDataSchema = import_zod3.z.object({
@@ -1065,6 +1066,7 @@ function validateRequestParams(req, routeData, validationSchema) {
   });
 }
 function validateRequestSingleParam(requestValue, requestParam) {
+  if (requestParam.isNullable && requestValue === null) return;
   requestParam.validator.forEach((validator) => {
     switch (validator.type) {
       case "TYPE_CHECK":
@@ -1244,6 +1246,10 @@ function convertTable(table) {
 // src/restura/sql/PsqlEngine.ts
 var import_core_utils5 = require("@redskytech/core-utils");
 
+// src/restura/sql/PsqlPool.ts
+var import_pg = __toESM(require("pg"));
+var import_pg_format2 = __toESM(require("pg-format"));
+
 // src/restura/sql/PsqlUtils.ts
 var import_pg_format = __toESM(require("pg-format"));
 function escapeColumnName(columnName) {
@@ -1279,7 +1285,9 @@ function isValueNumber2(value) {
 function SQL(strings, ...values) {
   let query = strings[0];
   values.forEach((value, index) => {
-    if (isValueNumber2(value)) {
+    if (typeof value === "boolean") {
+      query += value;
+    } else if (typeof value === "number") {
       query += value;
     } else {
       query += import_pg_format.default.literal(value);
@@ -1289,6 +1297,76 @@ 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);
+    });
+  }
+  // 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);
+      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];
+    } catch (error) {
+      console.error(error, query, options);
+      if (RsError.isRsError(error)) throw error;
+      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+  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);
+      return response.rows;
+    } catch (error) {
+      console.error(error, query, options);
+      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
+        throw new RsError("DUPLICATE", error.message);
+      }
+      throw new RsError("DATABASE_ERROR", `${error.message}`);
+    }
+  }
+  logSqlStatement(query, options, requesterDetails, prefix = "") {
+    if (logger.level !== "silly") return;
+    let sqlStatement = "";
+    if (options.length === 0) {
+      sqlStatement = query;
+    } else {
+      let stringIndex = 0;
+      sqlStatement = query.replace(/\$\d+/g, () => {
+        const value = options[stringIndex++];
+        if (typeof value === "number") return value.toString();
+        return import_pg_format2.default.literal(value);
+      });
+    }
+    let initiator = "Anonymous";
+    if ("userId" in requesterDetails && requesterDetails.userId)
+      initiator = `User Id (${requesterDetails.userId.toString()})`;
+    if ("isSystemUser" in requesterDetails && requesterDetails.isSystemUser) initiator = "SYSTEM";
+    logger.silly(`${prefix}query by ${initiator}, Query ->
+ ${sqlStatement}`);
+  }
+};
+
 // src/restura/sql/SqlEngine.ts
 var import_core_utils4 = require("@redskytech/core-utils");
 var SqlEngine = class {
@@ -1393,6 +1471,57 @@ var SqlEngine = class {
 // src/restura/sql/filterPsqlParser.ts
 var import_pegjs = __toESM(require("pegjs"));
 var filterSqlGrammar = `
+{
+// ported from pg-format but intentionally will add double quotes to every column
+ function quoteSqlIdentity(value) {
+    if (value === undefined || value === null) {
+        throw new Error('SQL identifier cannot be null or undefined');
+    } else if (value === false) {
+        return '"f"';
+    } else if (value === true) {
+        return '"t"';
+    } else if (value instanceof Date) {
+        // return '"' + formatDate(value.toISOString()) + '"';
+    } else if (value instanceof Buffer) {
+        throw new Error('SQL identifier cannot be a buffer');
+    } else if (Array.isArray(value) === true) {
+        var temp = [];
+        for (var i = 0; i < value.length; i++) {
+            if (Array.isArray(value[i]) === true) {
+                throw new Error('Nested array to grouped list conversion is not supported for SQL identifier');
+            } else {
+                // temp.push(quoteIdent(value[i]));
+            }
+        }
+        return temp.toString();
+    } else if (value === Object(value)) {
+        throw new Error('SQL identifier cannot be an object');
+    }
+
+    var ident = value.toString().slice(0); // create copy
+
+    // do not quote a valid, unquoted identifier
+    // if (/^[a-z_][a-z0-9_$]*$/.test(ident) === true && isReserved(ident) === false) {
+    //     return ident;
+    // }
+
+    var quoted = '"';
+
+    for (var i = 0; i < ident.length; i++) {
+        var c = ident[i];
+        if (c === '"') {
+            quoted += c + c;
+        } else {
+            quoted += c;
+        }
+    }
+
+    quoted += '"';
+
+    return quoted;
+};
+}
+
 start = expressionList
 
 expressionList =
@@ -1411,9 +1540,9 @@ negate = "!"
 operator = "and"i / "or"i
 
 	   
-column = left:text "." right:text { return  \`\${format.ident(left)}.\${format.ident(right)}\`; } 
+column = left:text "." right:text { return  \`\${quoteSqlIdentity(left)}.\${quoteSqlIdentity(right)}\`; } 
     / 
-    text:text { return format.ident(text); } 
+    text:text { return quoteSqlIdentity(text); } 
     
 
 text = text:[a-z0-9-_:@]i+ { return text.join("");}
@@ -1439,18 +1568,155 @@ 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 import_pg2 = require("pg");
+var systemUser = {
+  role: "",
+  host: "",
+  ipAddress: "",
+  isSystemUser: true
+};
 var PsqlEngine = class extends SqlEngine {
   constructor(psqlConnectionPool) {
     super();
     this.psqlConnectionPool = psqlConnectionPool;
   }
-  async diffDatabaseToSchema(schema) {
-    console.log(schema);
-    return Promise.resolve("");
+  async createDatabaseFromSchema(schema, connection) {
+    const sqlFullStatement = this.generateDatabaseSchemaFromSchema(schema);
+    await connection.runQuery(sqlFullStatement, [], systemUser);
+    return sqlFullStatement;
   }
   generateDatabaseSchemaFromSchema(schema) {
-    console.log(schema);
-    return "";
+    const sqlStatements = [];
+    const enums = [];
+    const indexes = [];
+    for (const table of schema.database) {
+      let sql = `CREATE TABLE "${table.name}"
+					   ( `;
+      const tableColumns = [];
+      for (const column of table.columns) {
+        let columnSql = "";
+        if (column.type === "ENUM") {
+          enums.push(`CREATE TYPE ${schemaToPsqlType(column, table.name)} AS ENUM (${column.value});`);
+        }
+        columnSql += `	"${column.name}" ${schemaToPsqlType(column, table.name)}`;
+        let value = column.value;
+        if (column.type === "JSON") value = "";
+        if (column.type === "JSONB") value = "";
+        if (column.type === "DECIMAL" && value) {
+          value = value.replace("-", ",").replace(/['"]/g, "");
+        }
+        if (value && column.type !== "ENUM") {
+          columnSql += `(${value})`;
+        } else if (column.length) columnSql += `(${column.length})`;
+        if (column.isPrimary) {
+          columnSql += " PRIMARY KEY ";
+        }
+        if (column.isUnique) {
+          columnSql += ` CONSTRAINT "${table.name}_${column.name}_unique_index" UNIQUE `;
+        }
+        if (column.isNullable) columnSql += " NULL";
+        else columnSql += " NOT NULL";
+        if (column.default) columnSql += ` DEFAULT '${column.default}'`;
+        tableColumns.push(columnSql);
+      }
+      sql += tableColumns.join(", \n");
+      for (const index of table.indexes) {
+        if (!index.isPrimaryKey) {
+          let unique = " ";
+          if (index.isUnique) unique = "UNIQUE ";
+          indexes.push(
+            `	CREATE ${unique}INDEX "${index.name}" ON "${table.name}" (${index.columns.map((item) => {
+              return `"${item}" ${index.order}`;
+            }).join(", ")})`
+          );
+        }
+      }
+      sql += "\n);";
+      sqlStatements.push(sql);
+    }
+    for (const table of schema.database) {
+      if (!table.foreignKeys.length) continue;
+      const sql = `ALTER TABLE "${table.name}" `;
+      const constraints = [];
+      for (const foreignKey of table.foreignKeys) {
+        let constraint = `	 ADD CONSTRAINT "${foreignKey.name}"
+        FOREIGN KEY ("${foreignKey.column}") REFERENCES "${foreignKey.refTable}" ("${foreignKey.refColumn}")`;
+        constraint += ` ON DELETE ${foreignKey.onDelete}`;
+        constraint += ` ON UPDATE ${foreignKey.onUpdate}`;
+        constraints.push(constraint);
+      }
+      sqlStatements.push(sql + constraints.join(",\n") + ";");
+    }
+    for (const table of schema.database) {
+      if (!table.checkConstraints.length) continue;
+      const sql = `ALTER TABLE "${table.name}" `;
+      const constraints = [];
+      for (const check of table.checkConstraints) {
+        const constraint = `ADD CONSTRAINT "${check.name}" CHECK (${check.check})`;
+        constraints.push(constraint);
+      }
+      sqlStatements.push(sql + constraints.join(",\n") + ";");
+    }
+    sqlStatements.push(indexes.join(";\n"));
+    return enums.join("\n") + "\n" + sqlStatements.join("\n\n");
+  }
+  async getScratchPool() {
+    await this.psqlConnectionPool.runQuery(
+      `DROP DATABASE IF EXISTS ${this.psqlConnectionPool.poolConfig.database}_scratch`,
+      [],
+      systemUser
+    );
+    await this.psqlConnectionPool.runQuery(
+      `CREATE DATABASE ${this.psqlConnectionPool.poolConfig.database}_scratch;`,
+      [],
+      systemUser
+    );
+    const scratchPool = new PsqlPool({
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port,
+      user: this.psqlConnectionPool.poolConfig.user,
+      database: this.psqlConnectionPool.poolConfig.database + "_scratch",
+      password: this.psqlConnectionPool.poolConfig.password,
+      max: this.psqlConnectionPool.poolConfig.max,
+      idleTimeoutMillis: this.psqlConnectionPool.poolConfig.idleTimeoutMillis,
+      connectionTimeoutMillis: this.psqlConnectionPool.poolConfig.connectionTimeoutMillis
+    });
+    return scratchPool;
+  }
+  async diffDatabaseToSchema(schema) {
+    const scratchPool = await this.getScratchPool();
+    await this.createDatabaseFromSchema(schema, scratchPool);
+    const originalClient = new import_pg2.Client({
+      database: this.psqlConnectionPool.poolConfig.database,
+      user: this.psqlConnectionPool.poolConfig.user,
+      password: this.psqlConnectionPool.poolConfig.password,
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port
+    });
+    const scratchClient = new import_pg2.Client({
+      database: this.psqlConnectionPool.poolConfig.database + "_scratch",
+      user: this.psqlConnectionPool.poolConfig.user,
+      password: this.psqlConnectionPool.poolConfig.password,
+      host: this.psqlConnectionPool.poolConfig.host,
+      port: this.psqlConnectionPool.poolConfig.port
+    });
+    await originalClient.connect();
+    await scratchClient.connect();
+    const info1 = await (0, import_pg_info.default)({
+      client: originalClient,
+      schema: "public"
+    });
+    const info2 = await (0, import_pg_info.default)({
+      client: scratchClient,
+      schema: "public"
+    });
+    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");
   }
   createNestedSelect(req, schema, item, routeData, userRole, sqlParams) {
     if (!item.subquery) return "";
@@ -1726,81 +1992,16 @@ ${sqlStatement};`,
     return whereClause;
   }
 };
-
-// src/restura/sql/PsqlPool.ts
-var import_pg = __toESM(require("pg"));
-var import_pg_format2 = __toESM(require("pg-format"));
-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);
-    });
-  }
-  // 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);
-      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];
-    } catch (error) {
-      console.error(error, query, options);
-      if (RsError.isRsError(error)) throw error;
-      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
-    }
-  }
-  // eslint-disable-next-line  @typescript-eslint/no-explicit-any
-  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);
-      return response.rows;
-    } catch (error) {
-      console.error(error, query, options);
-      if ((error == null ? void 0 : error.routine) === "_bt_check_unique") {
-        throw new RsError("DUPLICATE", error.message);
-      }
-      throw new RsError("DATABASE_ERROR", `${error.message}`);
-    }
-  }
-  logSqlStatement(query, options, requesterDetails, prefix = "") {
-    if (logger.level !== "silly") return;
-    let sqlStatement = "";
-    if (options.length === 0) {
-      sqlStatement = query;
-    } else {
-      let stringIndex = 0;
-      sqlStatement = query.replace(/\$\d+/g, () => {
-        const value = options[stringIndex++];
-        if (typeof value === "number") return value.toString();
-        return import_pg_format2.default.literal(value);
-      });
-    }
-    let initiator = "Anonymous";
-    if ("userId" in requesterDetails && requesterDetails.userId)
-      initiator = `User Id (${requesterDetails.userId.toString()})`;
-    if ("isSystemUser" in requesterDetails && requesterDetails.isSystemUser) initiator = "SYSTEM";
-    logger.silly(`${prefix}query by ${initiator}, Query ->
- ${sqlStatement}`);
-  }
+var 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/restura.ts
-var { types } = import_pg2.default;
+var { types } = import_pg3.default;
 var ResturaEngine = class {
   constructor() {
     this.publicEndpoints = {