@graphoria/server 0.1.0

package/src/databases/schemaBuilder/generateInsert/index.ts

@@ -0,0 +1,47 @@
+import type { DatabaseType } from "../../../types/configuration";
+import type { TableResolver } from "../../../types/db";
+
+export const generateInsertSQL =
+  (toDb: DatabaseType) =>
+  // oxlint-disable-next-line typescript/no-explicit-any
+  (table: TableResolver, data: Record<string, any>[]) => {
+    const columnNames = table.columns.map((column) => {
+      if (toDb === "mssql") {
+        return column.name;
+      } else if (toDb === "mysql") {
+        return `\`${column.name}\``;
+      } else {
+        return `"${column.name}"`;
+      }
+    });
+
+    const valueRows = data.map((row) => {
+      const values = table.columns.map((column) => {
+        const value = row[column.name];
+        if (typeof value === "string") {
+          return toDb === "mssql" ? `N'${value}'` : `'${value}'`;
+        }
+        return value;
+      });
+      return `(${values.join(",")})`;
+    });
+
+    if (toDb === "pg") {
+      return `INSERT INTO ${table?.dottedQuotedName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
+    } else if (toDb === "mssql") {
+      return `INSERT INTO ${table?.dottedName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
+    } else if (toDb === "mysql") {
+      // Generate backtick version of dotted name
+      const parts = table.dottedName.split(".");
+      const dottedBacktickName = parts.map((p) => `\`${p}\``).join(".");
+      return `INSERT INTO ${dottedBacktickName} (${columnNames.join(",")}) VALUES\n${valueRows.join(",\n")}`;
+    }
+
+    return "";
+  };
+
+export type GenerateInsertSQL = ReturnType<typeof generateInsertSQL>;
+
+export const generateInsertSQLMSSQL = generateInsertSQL("mssql");
+export const generateInsertSQLPostgreSQL = generateInsertSQL("pg");
+export const generateInsertSQLMySQL = generateInsertSQL("mysql");

package/src/databases/schemaBuilder/generateSchemaCreation/index.ts

@@ -0,0 +1,29 @@
+import type { DatabaseType } from "../../../types/configuration";
+
+export const generateSchemaCreationSQL =
+  (toDb: DatabaseType) =>
+  (schema: string, schemaCreationIfExists = true) => {
+    let sql = "";
+
+    if (toDb === "pg") {
+      sql += `CREATE SCHEMA ${schemaCreationIfExists ? "IF NOT EXISTS " : ""}"${schema}";`;
+    } else if (toDb === "mssql") {
+      if (schemaCreationIfExists) {
+        sql += `IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '${schema}')\n`;
+        sql += `  EXEC('CREATE SCHEMA [${schema}]');`;
+      } else {
+        sql += `CREATE SCHEMA ${schema};`;
+      }
+    } else if (toDb === "mysql") {
+      // In MySQL, schemas and databases are the same thing
+      sql += `CREATE DATABASE ${schemaCreationIfExists ? "IF NOT EXISTS " : ""}\`${schema}\`;`;
+    }
+
+    return sql;
+  };
+
+export type GenerateSchemaCreationSQL = ReturnType<typeof generateSchemaCreationSQL>;
+
+export const generateSchemaCreationMSSQL = generateSchemaCreationSQL("mssql");
+export const generateSchemaCreationPostgreSQL = generateSchemaCreationSQL("pg");
+export const generateSchemaCreationMySQL = generateSchemaCreationSQL("mysql");

package/src/databases/schemaBuilder/mssqlToPostgres/convertView.ts

@@ -0,0 +1,47 @@
+export const convertMSSQLViewToPostgres = (viewDefinition: string): string => {
+  return (
+    viewDefinition
+      // Fix CAST syntax
+      .replace(/cast\(([^)]+)\s+as\s+([^)]+)\)/gi, "$1::$2")
+
+      // Replace ISNULL with COALESCE
+      .replace(/ISNULL\s*\(([^,]+),([^)]+)\)/gi, "COALESCE($1,$2)")
+
+      // Replace string concatenation + with ||
+      .replace(/\s*\+\s*(?=('[^']*'|[^']+))/g, " || ")
+
+      // Replace TOP with LIMIT
+      .replace(/TOP\s+(\d+)/gi, "LIMIT $1")
+
+      // Replace LEN with LENGTH
+      .replace(/LEN\s*\(([^)]+)\)/gi, "LENGTH($1)")
+
+      // Remove square brackets from identifiers
+      .replace(/\[([^\]]+)\]/g, '"$1"')
+
+      // Replace CHARINDEX with POSITION
+      .replace(/CHARINDEX\s*\(([^,]+),([^)]+)\)/gi, "POSITION($1 IN $2)")
+
+      // Replace GETDATE() with CURRENT_TIMESTAMP
+      .replace(/GETDATE\(\)/gi, "CURRENT_TIMESTAMP")
+
+      // Replace SUBSTRING with proper syntax
+      .replace(/substring\s*\(([^,]+),([^,)]+)\)/gi, "substring($1 from $2)")
+
+      // Fix numeric types
+      .replace(/numeric\s*\(([^)]+)\)/gi, "numeric($1)")
+
+      // Fix boolean comparisons
+      .replace(/=\s*1/g, " = true")
+      .replace(/=\s*0/g, " = false")
+
+      // Fix CONVERT
+      .replace(/CONVERT\s*\(\s*([^,]+)\s*,\s*([^)]+)\s*\)/gi, "$2::$1")
+
+      // Fix CREATE VIEW syntax
+      .replace(
+        /CREATE\s+VIEW\s+(\[?)(\w+)(\]?)\.(\[?)(\w+)(\]?)/gi,
+        'CREATE OR REPLACE VIEW "$2"."$5"',
+      )
+  );
+};

package/src/databases/schemaBuilder/utils.ts

@@ -0,0 +1,17 @@
+export const splitInternalName = (internalName: string, helpers: boolean = false) => {
+  const [schema, ...nameSegments] = internalName.split("_");
+
+  const name = nameSegments.join("_");
+
+  return {
+    schema,
+    name,
+    ...(helpers
+      ? {
+          nameDashed: `${schema}_${name}`,
+          nameDotted: `${schema}.${name}`,
+          nameDottedQuoted: `"${schema}"."${name}"`,
+        }
+      : {}),
+  };
+};

package/src/databases/sqlTypeUtils.ts

@@ -0,0 +1,91 @@
+/**
+ * Utility functions for SQL data type categorization and mapping
+ * Supports MSSQL, MySQL, and PostgreSQL data types
+ */
+
+export enum SqlTypeCategory {
+  INTEGER = "INTEGER",
+  FLOAT = "FLOAT",
+  BOOLEAN = "BOOLEAN",
+  DATE_TIME = "DATE_TIME",
+  STRING = "STRING",
+}
+
+/**
+ * Categorizes a SQL data type into one of the standard categories
+ * @param dataType - The SQL data type to categorize (case-insensitive)
+ * @returns The category of the data type
+ */
+export const categorizeSqlType = (dataType: string): SqlTypeCategory => {
+  const lowerType = dataType.toLowerCase();
+
+  // Integer types (all databases)
+  if (
+    lowerType === "int" ||
+    lowerType === "integer" ||
+    lowerType === "smallint" ||
+    lowerType === "bigint" ||
+    lowerType === "tinyint" ||
+    lowerType === "mediumint" ||
+    lowerType === "numeric" ||
+    lowerType === "number"
+  ) {
+    return SqlTypeCategory.INTEGER;
+  }
+
+  // Floating-point types (all databases)
+  if (
+    lowerType === "float" ||
+    lowerType === "real" ||
+    lowerType === "double" ||
+    lowerType === "double precision" ||
+    lowerType === "decimal" ||
+    lowerType === "money" ||
+    lowerType === "smallmoney"
+  ) {
+    return SqlTypeCategory.FLOAT;
+  }
+
+  // Boolean types (all databases)
+  if (lowerType === "bit" || lowerType === "bool" || lowerType === "boolean") {
+    return SqlTypeCategory.BOOLEAN;
+  }
+
+  // Date and time types (all databases)
+  if (
+    lowerType === "date" ||
+    lowerType === "time" ||
+    lowerType === "datetime" ||
+    lowerType === "datetime2" ||
+    lowerType === "smalldatetime" ||
+    lowerType === "timestamp" ||
+    lowerType === "timestamptz" ||
+    lowerType === "timestamp with time zone" ||
+    lowerType === "timestamp without time zone" ||
+    lowerType === "time with time zone" ||
+    lowerType === "time without time zone" ||
+    lowerType === "timetz" ||
+    lowerType === "year" ||
+    lowerType === "interval"
+  ) {
+    return SqlTypeCategory.DATE_TIME;
+  }
+
+  // All other types default to STRING
+  // This includes:
+  // - Character strings: char, varchar, nchar, nvarchar, text, ntext, tinytext, mediumtext, longtext
+  // - Binary types: binary, varbinary, image, blob, tinyblob, mediumblob, longblob, bytea
+  // - Special types: uniqueidentifier, uuid, guid, xml, json, jsonb, sql_variant, geography, geometry, hierarchyid, datetimeoffset, cursor, table, vector, enum, set
+  // - PostgreSQL-specific: inet, cidr, macaddr, macaddr8, point, line, lseg, box, path, polygon, circle, tsquery, tsvector, ranges, array types
+  return SqlTypeCategory.STRING;
+};
+
+/**
+ * Checks if a SQL data type is numeric (integer or floating-point)
+ * @param dataType - The SQL data type to check
+ * @returns True if the type is numeric, false otherwise
+ */
+export const isNumericType = (dataType: string): boolean => {
+  const category = categorizeSqlType(dataType);
+  return category === SqlTypeCategory.INTEGER || category === SqlTypeCategory.FLOAT;
+};

package/src/databases/transformers/data-transformers.ts

@@ -0,0 +1,128 @@
+import type { Database, Relationships } from "../../types/configuration";
+import type { RelationshipResolver, StoredProcedure, Table, Tables } from "../../types/db";
+
+import { genResolverName } from "./genResolverName";
+
+/**
+ * Data transformation functions for converting database objects to internal formats
+ */
+
+export const buildRelationshipResolver = (
+  table: Table,
+  foreignKey: Relationships[number],
+  db: Database,
+  reversed = false,
+) => {
+  const internalName = genResolverName(
+    table.schema,
+    table.name,
+    table.entityType,
+    db.fieldNaming,
+    db.name,
+  );
+
+  const multipleRelationshipsWithTheSameTable =
+    table.foreignKeys.filter((fk) => fk.name === foreignKey.name && fk.schema === foreignKey.schema)
+      .length > 1;
+
+  const hasRelationshipsWithItself =
+    table.schema === foreignKey.schema && table.name === foreignKey.name;
+
+  let suffix = "";
+
+  if (multipleRelationshipsWithTheSameTable && hasRelationshipsWithItself) {
+    // Multiple self-referential FKs: use column names + direction to distinguish
+    const columnSuffix = foreignKey.columns.map((c) => c.source).join("_");
+    suffix = reversed ? `${columnSuffix}_list` : columnSuffix;
+  } else if (multipleRelationshipsWithTheSameTable) {
+    suffix = foreignKey.columns.map((c) => c.source).join("_");
+  } else if (hasRelationshipsWithItself) {
+    // Single self-referential FK: use ref/list pattern
+    suffix = reversed ? "list" : "ref";
+  }
+
+  return {
+    ...foreignKey,
+    internalName,
+    fromInternalName: genResolverName(
+      table.schema,
+      table.name,
+      table.entityType,
+      db.fieldNaming,
+      db.name,
+    ),
+    toInternalName: genResolverName(
+      foreignKey.schema,
+      foreignKey.name,
+      table.entityType,
+      db.fieldNaming,
+      db.name,
+    ),
+    fromResolverName: genResolverName(
+      table.schema,
+      table.name,
+      table.entityType,
+      db.fieldNaming,
+      db.name,
+      suffix,
+    ),
+    toResolverName: genResolverName(
+      foreignKey.schema,
+      foreignKey.name,
+      table.entityType,
+      db.fieldNaming,
+      db.name,
+      suffix,
+    ),
+  };
+};
+
+export const buildTableResolver = (tables: Tables, table: Table, db: Database) => {
+  const internalName = genResolverName(
+    table.schema,
+    table.name,
+    table.entityType,
+    db.fieldNaming,
+    db.name,
+  );
+
+  const relationships = table.foreignKeys.map((fk) => buildRelationshipResolver(table, fk, db));
+
+  const relationshipsReversed = tables.reduce<RelationshipResolver[]>((acc, t) => {
+    const reversed = t.foreignKeys.filter(
+      (f) => f.schema === table.schema && f.name === table.name,
+    );
+
+    if (reversed.length) {
+      acc.push(...reversed.map((fk) => buildRelationshipResolver(t, fk, db, true)));
+    }
+
+    return acc;
+  }, []);
+
+  return {
+    ...table,
+    db,
+    internalName,
+    resolverName: internalName,
+    relationships,
+    relationshipsReversed,
+  };
+};
+
+export const buildProcedureResolver = (sp: StoredProcedure, db: Database) => {
+  const internalName = genResolverName(sp.schema, sp.name, "sp", db.fieldNaming, db.name);
+  const dottedName = `${sp.schema}.${sp.name}`;
+
+  const resolverName = !db.fieldNaming
+    ? internalName
+    : genResolverName(sp.schema, sp.name, "sp", db.fieldNaming, db.name);
+
+  return {
+    ...sp,
+    db,
+    internalName,
+    resolverName,
+    dottedName,
+  };
+};

package/src/databases/transformers/genResolverName.ts

@@ -0,0 +1,18 @@
+export const genResolverName = (
+  schema: string,
+  name: string,
+  type: "table" | "view" | "sp",
+  fieldNaming: string = "{schema}_{name}",
+  dbName: string = "",
+  suffix?: string,
+) => {
+  const baseName = fieldNaming
+    .replace("{database}", dbName)
+    .replace("{type}", type)
+    .replace("{schema}", schema)
+    .replace("{name}", name);
+
+  if (suffix) return `${baseName}_${suffix}`;
+
+  return baseName;
+};