@graphoria/server 0.1.0

package/src/databases/high-level-operations.ts

@@ -0,0 +1,272 @@
+import { isString } from "es-toolkit";
+
+import type { RemoteRESTResolved } from "../remoteREST/types";
+import type { RemoteSchemaResolved } from "../remoteSchemas/types";
+import type {
+  Auth,
+  Database,
+  MessageQueue,
+  Operations,
+  Permissions,
+  TableFilter,
+  VirtualColumns,
+} from "../types/configuration";
+import type { Column, ProcedureResolver, TableResolver, Tables } from "../types/db";
+
+import { getDatabaseStructure } from "./metadata/structure";
+import { buildProcedureResolver, buildTableResolver } from "./transformers/data-transformers";
+import { genResolverName } from "./transformers/genResolverName";
+
+/**
+ * High-level database operations that combine multiple lower-level operations
+ */
+
+export const getDatabasesStructure = async (
+  databases: Database[],
+  auth?: Auth,
+  fetchStructure = getDatabaseStructure,
+) => {
+  const entities: TableResolver[] = [];
+  const enhancedStoredProcedures: ProcedureResolver[] = [];
+
+  // The auth user table holds the password hash and must never be served via
+  // the generated API. Its resolver key matches t.schemaName, which is always
+  // computed with the default `{schema}_{name}` naming (see enrichTable).
+  const authUserKey = auth?.enabled
+    ? genResolverName(auth.schema ?? "auth", "user", "table")
+    : undefined;
+
+  for (const db of databases) {
+    const { tables, storedProcedures } = await fetchStructure(db);
+
+    const tablesToAdd = tables
+      .reduce<Tables>((acc, t) => {
+        if (authUserKey && t.schemaName === authUserKey) return acc;
+        if (db.schema?.excludedTables.includes(t.schemaName)) return acc;
+
+        const tableOverride = db.schema?.database[t.schemaName];
+
+        if (!tableOverride) {
+          acc.push(t);
+
+          return acc;
+        }
+
+        if (tableOverride.description !== undefined) {
+          t.tableDescription = tableOverride.description;
+        }
+
+        for (const [colName, desc] of Object.entries(tableOverride.columnDescriptions)) {
+          const column = t.columns.find((col) => col.name.toLowerCase() === colName.toLowerCase());
+          if (column) column.description = desc;
+        }
+
+        if (tableOverride.columns.length) {
+          // Mix database columns with virtual columns from configuration
+          t.columns = [...t.columns, ...tableOverride.columns] as Column[];
+        }
+
+        if (tableOverride.relationships.length) {
+          const additionalForeignKeys = tableOverride.relationships.map((fk) => {
+            const toTable = tables.find(
+              (t) =>
+                `${fk.schema}_${fk.name}`.toLowerCase() === `${t.schema}_${t.name}`.toLowerCase(),
+            );
+
+            if (!toTable) {
+              throw new Error(`Referenced table ${fk.schema}_${fk.name} not found`);
+            }
+
+            return {
+              dashedName: `${fk.schema}_${fk.name}`,
+              schema: toTable.schema,
+              name: toTable.name,
+              columns: fk.columns.map((c) => {
+                const target = toTable.columns.find(
+                  (col) => col.name.toLowerCase() === c.target.toLowerCase(),
+                );
+
+                if (!target) {
+                  throw new Error(
+                    `Referenced column ${c.target} not found in table ${toTable.name}`,
+                  );
+                }
+
+                const tableColumn = t.columns.find(
+                  (col) => col.name.toLowerCase() === c.source.toLowerCase(),
+                );
+
+                if (!tableColumn) {
+                  throw new Error(`Column ${c.source} not found in table ${t.name}`);
+                }
+
+                return {
+                  source: tableColumn.name,
+                  target: target.name,
+                };
+              }),
+            };
+          });
+
+          if (additionalForeignKeys.length) {
+            t.foreignKeys = [...t.foreignKeys, ...additionalForeignKeys];
+          }
+        }
+
+        acc.push(t);
+
+        return acc;
+      }, [])
+      .map((t) => buildTableResolver(tables, t, db));
+
+    const storedProceduresToAdd = storedProcedures.map((sp) => buildProcedureResolver(sp, db));
+
+    entities.push(...tablesToAdd);
+    enhancedStoredProcedures.push(...storedProceduresToAdd);
+  }
+
+  return { tables: entities, storedProcedures: enhancedStoredProcedures };
+};
+
+export type EntitiesOfRole = {
+  tables: TableResolver[];
+  storedProcedures: ProcedureResolver[];
+  queues: MessageQueue[];
+  operations: Operations;
+  remoteSchemas: RemoteSchemaResolved[];
+  remoteREST: RemoteRESTResolved[];
+};
+
+/**
+ * Filters an array-shaped collection by a role's permission entry: `"ALL"`
+ * keeps everything, a `string[]` keeps items whose name (case-insensitive) is
+ * listed, anything else (undefined / malformed) keeps nothing. RBAC fails
+ * closed — an unrecognized permission shape grants no access.
+ */
+const filterByPermission = <T>(
+  items: T[],
+  permission: "ALL" | string[] | undefined,
+  getName: (item: T) => string,
+): T[] => {
+  if (permission === "ALL") return items;
+  if (!Array.isArray(permission)) return [];
+  const allowed = permission.map((name) => name.toLowerCase());
+  return items.filter((item) => allowed.includes(getName(item).toLowerCase()));
+};
+
+/**
+ * Record-keyed counterpart of {@link filterByPermission} for name-keyed
+ * collections (operations). Same `"ALL"` / allowlist / fail-closed rule.
+ */
+const filterRecordByPermission = <T>(
+  items: Record<string, T>,
+  permission: "ALL" | string[] | undefined,
+): Record<string, T> => {
+  if (permission === "ALL") return items;
+  if (!Array.isArray(permission)) return {};
+  const allowed = permission.map((name) => name.toLowerCase());
+  return Object.fromEntries(
+    Object.entries(items).filter(([name]) => allowed.includes(name.toLowerCase())),
+  );
+};
+
+export const sourcesForEachRole = (
+  tables: TableResolver[],
+  storedProcedures: ProcedureResolver[],
+  queues: MessageQueue[],
+  operations: Operations,
+  permissionsMapping: Permissions = {},
+  remoteSchemas: RemoteSchemaResolved[] = [],
+  remoteREST: RemoteRESTResolved[] = [],
+) =>
+  Object.entries(permissionsMapping).reduce<Record<string, EntitiesOfRole>>(
+    (acc, [role, permissions]) => {
+      // Lowercase-keyed view of permissions.tables so filter and column lookup
+      // see the same normalized shape. Without this, an uppercase permission
+      // key would pass the filter step but crash the column-allowlist lookup.
+      const permissionsTablesByLowerKey = !isString(permissions.tables)
+        ? Object.fromEntries(
+            Object.entries(permissions.tables).map(([k, v]) => [k.toLowerCase(), v]),
+          )
+        : null;
+
+      // Object-form permissions list the allowed tables as keys; "ALL" (the only
+      // string form left after zod normalization) keeps every table.
+      const allowedTables = filterByPermission(
+        tables,
+        permissionsTablesByLowerKey ? Object.keys(permissionsTablesByLowerKey) : "ALL",
+        (t) => t.resolverName,
+      );
+
+      const filteredTables: TableResolver[] = allowedTables.map((t) => {
+        let allowedColumns: VirtualColumns = t.columns as VirtualColumns;
+        let rolePermission: TableFilter | undefined;
+
+        if (permissionsTablesByLowerKey) {
+          const tablePerm = permissionsTablesByLowerKey[t.resolverName.toLowerCase()]!;
+
+          if (isString(tablePerm.columns) && tablePerm.columns === "ALL") {
+            allowedColumns = t.columns as VirtualColumns;
+          } else {
+            const columnsList = tablePerm.columns.map((col: string) => col.toLowerCase());
+
+            allowedColumns = t.columns.filter((c) =>
+              columnsList.includes(c.name.toLowerCase()),
+            ) as VirtualColumns;
+          }
+
+          rolePermission = { filter: tablePerm.filter, orderBy: tablePerm.orderBy };
+        }
+
+        return {
+          ...t,
+          columns: allowedColumns,
+          rolePermission,
+          relationships: t.relationships.filter(
+            (fk) =>
+              allowedTables.find((t) => t.resolverName === fk.fromInternalName) &&
+              allowedTables.find((t) => t.resolverName === fk.toInternalName),
+          ),
+          relationshipsReversed: t.relationshipsReversed.filter(
+            (fk) =>
+              allowedTables.find((t) => t.resolverName === fk.fromInternalName) &&
+              allowedTables.find((t) => t.resolverName === fk.toInternalName),
+          ),
+        };
+      });
+
+      const filteredStoredProcedures = filterByPermission(
+        storedProcedures,
+        permissions.storedProcedures,
+        (sp) => sp.name,
+      );
+
+      const filteredQueues = filterByPermission(queues, permissions.queues, (q) => q.name);
+
+      const filteredOperations = filterRecordByPermission(operations, permissions.operations);
+
+      const filteredRemoteSchemas = filterByPermission(
+        remoteSchemas,
+        permissions.remoteSchemas,
+        (rs) => rs.config.name,
+      );
+
+      const filteredRemoteREST = filterByPermission(
+        remoteREST,
+        permissions.remoteREST,
+        (rr) => rr.config.name,
+      );
+
+      acc[role] = {
+        tables: filteredTables,
+        storedProcedures: filteredStoredProcedures,
+        queues: filteredQueues,
+        operations: filteredOperations,
+        remoteSchemas: filteredRemoteSchemas,
+        remoteREST: filteredRemoteREST,
+      };
+
+      return acc;
+    },
+    {},
+  );

package/src/databases/index.ts

@@ -0,0 +1,28 @@
+// Core database operations
+export { executeQuery, executeQueryJSON, callStoredProcedure } from "./core/executor";
+
+export { generateSQL } from "./core/query-builder";
+
+export { databaseAdapters } from "./core/function-mapping";
+
+// Database metadata operations
+export { getDatabaseStructure, getViewsFromDB } from "./metadata/structure";
+
+// Authentication operations
+export {
+  createAuthTables,
+  getLoginFn,
+  checkUserCredentials,
+  insertAuthUser,
+  verifyAuthTablesExist,
+} from "./auth/auth-operations";
+
+// Data transformation operations
+export {
+  buildRelationshipResolver,
+  buildTableResolver,
+  buildProcedureResolver,
+} from "./transformers/data-transformers";
+
+// High-level operations
+export { getDatabasesStructure, sourcesForEachRole } from "./high-level-operations";

package/src/databases/metadata/structure.ts

@@ -0,0 +1,12 @@
+import type { Database } from "../../types/configuration";
+
+import { databaseAdapters } from "../core/function-mapping";
+
+/**
+ * Database metadata and structure retrieval functions
+ */
+
+export const getDatabaseStructure = async (db: Database) =>
+  databaseAdapters[db.type].getDatabaseStructure(db);
+
+export const getViewsFromDB = async (db: Database) => databaseAdapters[db.type].getViews(db);

package/src/databases/schemaBuilder/convert.ts

@@ -0,0 +1,121 @@
+import type { Database, DatabaseType } from "../../types/configuration";
+import type { DatabaseStructure, View } from "../../types/db";
+import type { GenerateCreateTablesSQL } from "./generateCreateTable";
+import type { GenerateCreateViewsSQL } from "./generateCreateView";
+import type { GenerateInsertSQL } from "./generateInsert";
+
+import { buildTableResolver, getDatabaseStructure, getViewsFromDB } from "..";
+import { generateCreateTablesSQL } from "./generateCreateTable";
+import {
+  generateCreateViewsMSSQL,
+  generateCreateViewsMySQL,
+  generateCreateViewsPostgreSQL,
+} from "./generateCreateView";
+import {
+  generateInsertSQLMSSQL,
+  generateInsertSQLMySQL,
+  generateInsertSQLPostgreSQL,
+} from "./generateInsert";
+
+const mapping: Record<
+  DatabaseType,
+  {
+    getTablesFromDB: (db: Database) => Promise<DatabaseStructure>;
+    getViewsFromDB: (db: Database) => Promise<View[]>;
+    generateCreateTablesSQL: GenerateCreateTablesSQL;
+    generateCreateViewsSQL: GenerateCreateViewsSQL;
+    generateInsertsSQL: GenerateInsertSQL;
+  }
+> = {
+  mssql: {
+    getTablesFromDB: getDatabaseStructure,
+    getViewsFromDB: getViewsFromDB,
+    generateCreateTablesSQL,
+    generateCreateViewsSQL: generateCreateViewsMSSQL,
+    generateInsertsSQL: generateInsertSQLMSSQL,
+  },
+  pg: {
+    getTablesFromDB: getDatabaseStructure,
+    getViewsFromDB: getViewsFromDB,
+    generateCreateTablesSQL,
+    generateCreateViewsSQL: generateCreateViewsPostgreSQL,
+    generateInsertsSQL: generateInsertSQLPostgreSQL,
+  },
+  mysql: {
+    getTablesFromDB: getDatabaseStructure,
+    getViewsFromDB: getViewsFromDB,
+    generateCreateTablesSQL,
+    generateCreateViewsSQL: generateCreateViewsMySQL,
+    generateInsertsSQL: generateInsertSQLMySQL,
+  },
+};
+
+const convertDatabase = async (
+  dbFrom: Database,
+  dbToType: DatabaseType,
+  tables: "ALL" | string[] = "ALL",
+) => {
+  const databaseFrom = mapping[dbFrom.type];
+  const databaseTo = mapping[dbToType];
+
+  const dbTo: Database = {
+    ...dbFrom,
+    type: dbToType,
+    name: `${dbFrom.name}_converted_to_${dbToType}`,
+  };
+
+  const fromTable = await databaseFrom.getTablesFromDB(dbFrom);
+  // const fromViews = await databaseFrom.getViewsFromDB(ciFrom);
+
+  const tablesToConvert =
+    tables === "ALL"
+      ? fromTable.tables
+      : fromTable.tables.filter((table) => tables.includes(table.name));
+
+  const convertedTables = databaseTo.generateCreateTablesSQL(dbTo, tablesToConvert);
+  // const convertedViews = databaseTo.generateCreateViewsSQL(fromViews);
+
+  const inserts = tablesToConvert.map((t) =>
+    databaseTo.generateInsertsSQL(buildTableResolver(fromTable.tables, t, dbFrom), [
+      {
+        product_id: 1,
+        sku: "ELEC-001",
+        name: "Wireless Keyboard",
+        description: "Ergonomic wireless keyboard",
+        price: 49.99,
+        is_active: 1,
+      },
+      {
+        product_id: 2,
+        sku: "ELEC-002",
+        name: "USB-C Hub",
+        description: "7-port USB-C hub",
+        price: 29.99,
+        is_active: 1,
+      },
+    ]),
+  );
+
+  return [convertedTables, inserts].join("\n\n");
+};
+
+await Bun.write(
+  "converted.sql",
+  await convertDatabase(
+    {
+      enabled: true,
+      name: "default",
+      type: "mssql",
+      connection: {
+        host: "localhost",
+        port: 1433,
+        user: "test",
+        password: "test",
+        database: "test",
+      },
+      fieldNaming: "{schema}_{name}",
+    },
+    "pg",
+    ["products"],
+  ),
+);

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

@@ -0,0 +1,133 @@
+import { uniq } from "es-toolkit";
+
+import type { Database, DatabaseType } from "../../../types/configuration";
+import type { TableResolver, Tables } from "../../../types/db";
+
+import { buildTableResolver } from "../../transformers/data-transformers";
+import { generateSchemaCreationSQL } from "../generateSchemaCreation";
+import { splitInternalName } from "../utils";
+
+const typeMapping: Record<DatabaseType, Record<string, string>> = {
+  mssql: {
+    varchar: "VARCHAR(MAX)",
+    int: "INT",
+    smallint: "SMALLINT",
+    nvarchar: "NVARCHAR(MAX)",
+    datetime: "DATETIME",
+    smalldatetime: "DATETIME",
+    image: "IMAGE",
+    uniqueidentifier: "UNIQUEIDENTIFIER",
+    tinyint: "TINYINT",
+  },
+  pg: {
+    varchar: "VARCHAR",
+    int: "INTEGER",
+    smallint: "SMALLINT",
+    nvarchar: "VARCHAR",
+    datetime: "TIMESTAMP",
+    smalldatetime: "TIMESTAMP",
+    image: "BYTEA",
+    uniqueidentifier: "UUID",
+    tinyint: "SMALLINT",
+  },
+  mysql: {
+    varchar: "VARCHAR(255)",
+    int: "INT",
+    smallint: "SMALLINT",
+    nvarchar: "VARCHAR(255)",
+    datetime: "DATETIME",
+    smalldatetime: "DATETIME",
+    image: "BLOB",
+    uniqueidentifier: "CHAR(36)",
+    tinyint: "TINYINT",
+  },
+};
+
+export type GenerateCreateTableSQLParameters = {
+  schemaCreation?: boolean;
+  schemaCreationIfExists?: boolean;
+  tableCreationIfExists?: boolean;
+};
+
+export const generateCreateTableSQL =
+  (toDb: DatabaseType) =>
+  (
+    table: TableResolver,
+    {
+      schemaCreation = true,
+      schemaCreationIfExists = true,
+      tableCreationIfExists = true,
+    }: GenerateCreateTableSQLParameters = {},
+  ) => {
+    const columnsSQL = table.columns
+      .map((column) => {
+        const targetType = typeMapping[toDb][column.dataType] || column.dataType.toUpperCase();
+        if (toDb === "mssql") {
+          return `  ${column.name} ${targetType}`;
+        } else if (toDb === "mysql") {
+          return `  \`${column.name}\` ${targetType}${column.isNullable ? " NULL" : " NOT NULL"}`;
+        } else {
+          return `  "${column.name}" ${targetType}${column.isNullable ? " NULL" : " NOT NULL"}`;
+        }
+      })
+      .join(",\n");
+
+    let sql = "";
+
+    const parsed = splitInternalName(`${table.schema}_${table.name}`, true);
+
+    // Schema creation
+    if (schemaCreation) {
+      sql += generateSchemaCreationSQL(toDb)(table.schema, schemaCreationIfExists);
+    }
+
+    // Table creation
+    if (toDb === "pg") {
+      sql += `CREATE TABLE ${tableCreationIfExists ? "IF NOT EXISTS " : ""}${parsed?.nameDottedQuoted} (\n${columnsSQL}\n);`;
+    } else if (toDb === "mssql") {
+      if (tableCreationIfExists) {
+        sql += `IF NOT EXISTS (SELECT * FROM sys.tables WHERE object_id = OBJECT_ID('${parsed?.nameDotted}'))\n`;
+      }
+      sql += `CREATE TABLE ${parsed?.nameDotted} (\n${columnsSQL}\n);`;
+    } else if (toDb === "mysql") {
+      // Generate backtick version of dotted name
+      if (parsed?.nameDotted) {
+        const parts = parsed.nameDotted.split(".");
+        const dottedBacktickName = parts.map((p) => `\`${p}\``).join(".");
+        sql += `CREATE TABLE ${tableCreationIfExists ? "IF NOT EXISTS " : ""}${dottedBacktickName} (\n${columnsSQL}\n);`;
+      }
+    }
+
+    return sql;
+  };
+
+export type GenerateCreateTableSQL = ReturnType<typeof generateCreateTableSQL>;
+
+export const generateCreateTableMSSQL = generateCreateTableSQL("mssql");
+export const generateCreateTablePostgreSQL = generateCreateTableSQL("pg");
+export const generateCreateTableMySQL = generateCreateTableSQL("mysql");
+
+export const generateCreateTablesSQL = (
+  db: Database,
+  tables: Tables,
+  options?: GenerateCreateTableSQLParameters,
+) => {
+  const schemas = uniq(tables.map((table) => table.schema)).filter(
+    (schema) => !!schema,
+  ) as string[];
+
+  return [
+    ...schemas.map((schema) => generateSchemaCreationSQL(db.type)(schema, true)),
+    tables
+      .filter((table) => table.entityType === "table")
+      .map((table) =>
+        generateCreateTableSQL(db.type)(buildTableResolver([table], table, db), {
+          ...options,
+          schemaCreation: false,
+        }),
+      )
+      .join("\n\n"),
+  ].join("\n\n");
+};
+
+export type GenerateCreateTablesSQL = typeof generateCreateTablesSQL;

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

@@ -0,0 +1,101 @@
+import type { DatabaseType } from "../../../types/configuration";
+import type { View } from "../../../types/db";
+
+import { generateSchemaCreationSQL } from "../generateSchemaCreation";
+import { convertMSSQLViewToPostgres } from "../mssqlToPostgres/convertView";
+import { splitInternalName } from "../utils";
+
+export type GenerateCreateViewSQLParameters = {
+  schemaCreation?: boolean;
+  schemaCreationIfExists?: boolean;
+  viewCreationIfExists?: boolean;
+  replaceExisting?: boolean;
+};
+
+const transformViewDefinition = (definition: string, toDb: DatabaseType): string => {
+  if (toDb === "pg") return convertMSSQLViewToPostgres(definition);
+
+  return (
+    definition
+      // Remove CREATE VIEW [...] AS part if present
+      .replace(/CREATE\s+VIEW\s+.*?AS\s+/i, "")
+      .trim()
+  );
+};
+
+export const generateCreateViewSQL =
+  (toDb: DatabaseType) =>
+  (
+    view: View,
+    {
+      schemaCreation = true,
+      schemaCreationIfExists = true,
+      viewCreationIfExists = true,
+      replaceExisting = false,
+    }: GenerateCreateViewSQLParameters = {},
+  ) => {
+    let sql = "";
+    const parsed = splitInternalName(view.name, true);
+
+    if (!parsed) return "";
+
+    // Schema creation if needed
+    if (schemaCreation) {
+      sql += generateSchemaCreationSQL(toDb)(parsed.schema, schemaCreationIfExists);
+      sql += "\n\n";
+    }
+
+    const transformedDefinition = transformViewDefinition(view.definition, toDb);
+
+    // View creation
+    if (toDb === "pg") {
+      if (replaceExisting) {
+        sql += `DROP VIEW IF EXISTS "${parsed.schema}"."${parsed.name}";\n`;
+        sql += `CREATE VIEW "${parsed.schema}"."${parsed.name}" AS\n${transformedDefinition};`;
+      } else if (viewCreationIfExists) {
+        sql += `CREATE OR REPLACE VIEW "${parsed.schema}"."${parsed.name}" AS\n${transformedDefinition};`;
+      }
+    } else if (toDb === "mssql") {
+      if (viewCreationIfExists || replaceExisting) {
+        sql += `IF EXISTS (SELECT * FROM sys.views WHERE object_id = OBJECT_ID('${parsed.nameDotted}'))\n`;
+        if (replaceExisting) {
+          sql += `  DROP VIEW ${parsed.nameDotted};\n`;
+        } else {
+          sql += `  RETURN;\n`;
+        }
+      }
+      sql += `CREATE VIEW ${parsed.nameDotted} AS\n${transformedDefinition};`;
+    }
+
+    return sql;
+  };
+
+export type GenerateCreateViewSQL = ReturnType<typeof generateCreateViewSQL>;
+
+export const generateCreateViewMSSQL = generateCreateViewSQL("mssql");
+export const generateCreateViewPostgreSQL = generateCreateViewSQL("pg");
+
+export const generateCreateViewsSQL =
+  (dbType: DatabaseType) => (views: View[], options?: GenerateCreateViewSQLParameters) => {
+    const schemas = [...new Set(views.map((view) => splitInternalName(view.name)?.schema))].filter(
+      Boolean,
+    ) as string[];
+
+    return [
+      ...schemas.map((schema) => generateSchemaCreationSQL(dbType)(schema)),
+      views
+        .map((view) =>
+          generateCreateViewSQL(dbType)(view, {
+            ...options,
+            schemaCreation: false,
+          }),
+        )
+        .join("\n\n"),
+    ].join("\n\n");
+  };
+
+export type GenerateCreateViewsSQL = ReturnType<typeof generateCreateViewsSQL>;
+
+export const generateCreateViewsMSSQL = generateCreateViewsSQL("mssql");
+export const generateCreateViewsPostgreSQL = generateCreateViewsSQL("pg");
+export const generateCreateViewsMySQL = generateCreateViewsSQL("mysql");