@graphoria/server 0.1.5 → 0.2.0

package/src/databases/engines/mysql/getStructure.ts

@@ -3,8 +3,23 @@ import type { Database } from "../../../types/configuration";
 import { DatabaseStructureZod } from "../../../types/zod/db";
 import { executeQueryJSONSingle } from "./connection";
 
+/**
+ * Ordering carried out of SQL and restored here: JSON_ARRAYAGG accepts no
+ * ORDER BY. GROUP_CONCAT does, but silently truncates at group_concat_max_len
+ * (1024 bytes by default), which any table past ~10 columns exceeds — the JSON
+ * is then cut mid-object and CAST(... AS JSON) fails.
+ */
+type Ordered = { ordinalPosition?: number };
+type RawForeignKey = { fkName?: string; columns: Ordered[] };
+type RawStructure = {
+  tables?: { columns?: Ordered[]; foreignKeys?: RawForeignKey[] }[];
+  storedProcedures?: { parameters?: Ordered[] }[];
+};
+
+const byOrdinal = (a: Ordered, b: Ordered) => (a.ordinalPosition ?? 0) - (b.ordinalPosition ?? 0);
+
 export const getDatabaseStructure = async (db: Database) => {
-  const res = await executeQueryJSONSingle(
+  const res = await executeQueryJSONSingle<RawStructure>(
     `
     SELECT JSON_OBJECT(
       'tables', JSON_ARRAYAGG(
@@ -31,7 +46,7 @@ export const getDatabaseStructure = async (db: Database) => {
             )
           )
           FROM information_schema.routines r
-          
+
           -- Parameters
           LEFT JOIN LATERAL (
             SELECT JSON_ARRAYAGG(
@@ -40,16 +55,16 @@ export const getDatabaseStructure = async (db: Database) => {
                 'dataType', p.data_type,
                 'maxLength', COALESCE(p.character_maximum_length, 0),
                 'precision', COALESCE(p.numeric_precision, 0),
-                'scale', COALESCE(p.numeric_scale, 0)
+                'scale', COALESCE(p.numeric_scale, 0),
+                'ordinalPosition', p.ordinal_position
               )
             ) AS param_array
             FROM information_schema.parameters p
             WHERE p.specific_name = r.specific_name
               AND p.specific_schema = r.routine_schema
               AND p.parameter_name IS NOT NULL
-            ORDER BY p.ordinal_position
           ) params ON true
-          
+
           WHERE r.routine_type IN ('FUNCTION', 'PROCEDURE')
           AND r.routine_schema NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
         ),
@@ -58,22 +73,20 @@ export const getDatabaseStructure = async (db: Database) => {
     ) as json_result
     FROM (
       SELECT table_schema, table_name, table_type
-      FROM information_schema.tables 
+      FROM information_schema.tables
       WHERE table_type IN ('BASE TABLE', 'VIEW')
         AND table_schema NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')
     ) t
     LEFT JOIN LATERAL (
-      -- build an ordered JSON array of columns using GROUP_CONCAT
-      SELECT IFNULL(
-        CAST(CONCAT('[', GROUP_CONCAT(
-          JSON_OBJECT(
-            'name', isc.column_name,
-            'dataType', isc.data_type,
-            'isNullable', CASE WHEN isc.is_nullable = 'YES' THEN true ELSE false END,
-            'collation', isc.collation_name,
-            'description', NULL
-          ) ORDER BY isc.ordinal_position SEPARATOR ','), ']') AS JSON),
-        JSON_ARRAY()
+      SELECT JSON_ARRAYAGG(
+        JSON_OBJECT(
+          'name', isc.column_name,
+          'dataType', isc.data_type,
+          'isNullable', CASE WHEN isc.is_nullable = 'YES' THEN true ELSE false END,
+          'collation', isc.collation_name,
+          'description', NULL,
+          'ordinalPosition', isc.ordinal_position
+        )
       ) AS columns
       FROM information_schema.columns isc
       WHERE isc.table_schema = t.table_schema
@@ -81,26 +94,28 @@ export const getDatabaseStructure = async (db: Database) => {
     ) col ON TRUE
     LEFT JOIN LATERAL (
       -- aggregate FKs: first aggregate columns per constraint, then aggregate constraints
-      SELECT IFNULL(
-        CAST(CONCAT('[', GROUP_CONCAT(
-          JSON_OBJECT(
-            'schema', fk_sub.referenced_table_schema,
-            'name', fk_sub.referenced_table_name,
-            'columns', fk_sub.columns_arr
-          ) ORDER BY fk_sub.fk_name SEPARATOR ','), ']') AS JSON),
-        JSON_ARRAY()
+      SELECT JSON_ARRAYAGG(
+        JSON_OBJECT(
+          'schema', fk_sub.referenced_table_schema,
+          'name', fk_sub.referenced_table_name,
+          'columns', fk_sub.columns_arr,
+          'fkName', fk_sub.fk_name
+        )
       ) AS fk_agg
       FROM (
-        SELECT 
+        SELECT
           kcu.constraint_name AS fk_name,
           kcu.table_schema,
           kcu.table_name,
           kcu.referenced_table_schema,
           kcu.referenced_table_name,
-          CAST(CONCAT('[', GROUP_CONCAT(
-            JSON_OBJECT('source', kcu.column_name, 'target', kcu.referenced_column_name)
-            ORDER BY kcu.ordinal_position SEPARATOR ','
-          ), ']') AS JSON) AS columns_arr
+          JSON_ARRAYAGG(
+            JSON_OBJECT(
+              'source', kcu.column_name,
+              'target', kcu.referenced_column_name,
+              'ordinalPosition', kcu.ordinal_position
+            )
+          ) AS columns_arr
         FROM information_schema.key_column_usage kcu
         WHERE kcu.referenced_table_schema IS NOT NULL
           AND kcu.table_schema = t.table_schema
@@ -113,5 +128,21 @@ export const getDatabaseStructure = async (db: Database) => {
     db,
   );
 
+  for (const table of res.tables ?? []) {
+    table.columns?.sort(byOrdinal);
+    table.foreignKeys?.sort((a, b) => (a.fkName ?? "").localeCompare(b.fkName ?? ""));
+
+    // TableRelationshipZod is strict, so the ordering keys must go before parsing.
+    for (const foreignKey of table.foreignKeys ?? []) {
+      foreignKey.columns.sort(byOrdinal);
+      for (const column of foreignKey.columns) delete column.ordinalPosition;
+      delete foreignKey.fkName;
+    }
+  }
+
+  for (const storedProcedure of res.storedProcedures ?? []) {
+    storedProcedure.parameters?.sort(byOrdinal);
+  }
+
   return DatabaseStructureZod.parse(res);
 };

package/src/databases/engines/mysql/placeholders.ts

@@ -0,0 +1,84 @@
+import type { VariableDefinition } from "../../../analyzeQuery/types";
+
+/**
+ * Rewrites the builder's PostgreSQL-style `$n` placeholders to MySQL's `?`.
+ *
+ * The query builders are shared across engines and number placeholders by index
+ * into `variablesDefinition`. Bun's MySQL adapter binds `?` by position of
+ * occurrence in the statement text, and the two orders do not match: the WHERE
+ * string is interpolated into more than one sub-statement on the aggregate path,
+ * nested subqueries are built before the outer WHERE is appended, and a single
+ * directive can emit `$2` before `$1` and `$1` twice. Rewriting here — the one
+ * point where the finished statement and its values meet — makes text order the
+ * binding order by construction.
+ *
+ * The scan skips quoted runs because generated SQL does carry `$n` inside string
+ * literals: a config-supplied relationship condition value is interpolated as a
+ * literal, and introspected identifiers may contain `$`.
+ */
+export const toMySQLPlaceholders = (
+  query: string,
+  variablesDefinition: VariableDefinition[] = [],
+  values: Record<string, unknown> = {},
+): { query: string; params: unknown[] } => {
+  const params: unknown[] = [];
+  let rewritten = "";
+  let index = 0;
+
+  while (index < query.length) {
+    const char = query[index]!;
+
+    if (char === "'" || char === '"' || char === "`") {
+      const start = index;
+      index++;
+
+      while (index < query.length) {
+        // Backslash escapes apply inside string literals but never inside a
+        // backtick-quoted identifier, where the only escape is a doubled tick.
+        if (char !== "`" && query[index] === "\\") {
+          index += 2;
+          continue;
+        }
+        if (query[index] === char) {
+          if (query[index + 1] === char) {
+            index += 2;
+            continue;
+          }
+          index++;
+          break;
+        }
+        index++;
+      }
+
+      rewritten += query.slice(start, index);
+      continue;
+    }
+
+    if (char === "$") {
+      const match = /^\$(\d+)/.exec(query.slice(index));
+
+      if (match) {
+        const position = Number(match[1]);
+        const definition = variablesDefinition[position - 1];
+
+        if (!definition) {
+          throw new Error(
+            `MySQL query references $${position} but only ${variablesDefinition.length} variable${
+              variablesDefinition.length === 1 ? " is" : "s are"
+            } defined`,
+          );
+        }
+
+        params.push(values[definition.name]);
+        rewritten += "?";
+        index += match[0].length;
+        continue;
+      }
+    }
+
+    rewritten += char;
+    index++;
+  }
+
+  return { query: rewritten, params };
+};

package/src/databases/engines/mysql/query/index.ts

@@ -19,6 +19,8 @@ import {
   wrapIdentifierMySQL,
 } from "../../../common";
 
+import { applyDirectives } from "../../../directives";
+
 // Generate CTE for aggregations
 const buildAggregationCTE = (
   groupByInfo: GroupByInfo,
@@ -61,6 +63,7 @@ const buildAggregationCTE = (
 // Build the main query for grouped results
 const buildGroupedQuery = (
   entities: MergedEntities,
+  variablesDefinition: VariableDefinition[],
   field: SelectionAnalysis,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
@@ -75,7 +78,15 @@ const buildGroupedQuery = (
   if (hasKey) {
     // Add key object with group by fields
     const keyFields = keys
-      .map((key) => `'${key.alias || key.name}', ${cteAlias}.${wrapIdentifierMySQL(key.name)}`)
+      .map((key) => {
+        const selector = applyDirectives(
+          `${cteAlias}.${wrapIdentifierMySQL(key.name)}`,
+          key.directives,
+          "mysql",
+          variablesDefinition,
+        );
+        return `'${key.alias || key.name}', ${selector}`;
+      })
       .join(", ");
 
     selectClauses.push(`'${keyResolved}', JSON_OBJECT(${keyFields})`);
@@ -99,7 +110,15 @@ const buildGroupedQuery = (
     if (itemsSelection?.selections) {
       const itemFields = itemsSelection.selections
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
-        .map((sel) => `'${sel.alias || sel.name}', ${tableAlias}.${wrapIdentifierMySQL(sel.name)}`)
+        .map((sel) => {
+          const selector = applyDirectives(
+            `${tableAlias}.${wrapIdentifierMySQL(sel.name)}`,
+            sel.directives,
+            "mysql",
+            variablesDefinition,
+          );
+          return `'${sel.alias || sel.name}', ${selector}`;
+        })
         .join(", ");
 
       if (itemFields) {
@@ -244,6 +263,7 @@ export const buildSQLForField = (
     // Handle GROUP BY aggregation query
     const mainQuery = buildGroupedQuery(
       entities,
+      variablesDefinition,
       field,
       groupByInfo,
       dottedQuotedName,
@@ -277,16 +297,41 @@ export const buildSQLForField = (
     ([name, selector]) => `'${name}', ${selector}`,
   );
 
-  const fromClause = `FROM ${dottedQuotedName} ${tableAlias}${withoutArrayWrapper ? " LIMIT 1" : ""}`;
+  const fromClause = `FROM ${dottedQuotedName} ${tableAlias}`;
 
   const orderByClause = buildOrderByClauseMySQL(entities, field, tableAlias);
   const paginationClause = buildPaginationClauseMySQL(field, variablesDefinition);
 
   const isArraySelection = !!field.isArray && !withoutArrayWrapper;
 
+  // JSON_ARRAYAGG accepts no ORDER BY of its own and collapses the rows before
+  // LIMIT can trim them, so both ordering and pagination have to happen in a
+  // derived table that the aggregate then reads.
+  if (isArraySelection && (orderByClause || paginationClause)) {
+    const pageAlias = `${tableAlias}_page`;
+    // A nested selection is correlated to its parent through the where clause,
+    // and a plain derived table may not carry an outer reference. LATERAL lifts
+    // that restriction — MySQL 8.0.14 and newer. Unordered, unpaginated nested
+    // selections never take this branch, so older servers keep working for them.
+    const lateral = parentTableName ? "LATERAL " : "";
+
+    // NO_MERGE is load-bearing, not a hint about performance: without it MySQL
+    // merges the derived table into the outer query and discards its ORDER BY,
+    // so the array comes back in storage order. A LIMIT blocks the merge on its
+    // own, which is why only the unpaginated ordering was affected.
+    return `
+    COALESCE((
+      SELECT /*+ NO_MERGE(${pageAlias}) */ JSON_ARRAYAGG(${pageAlias}.obj)
+      FROM ${lateral}(
+        SELECT JSON_OBJECT(${selectList}) AS obj ${fromClause} ${whereClause} ${orderByClause} ${paginationClause}
+      ) ${pageAlias}
+    ), JSON_ARRAY())
+  `;
+  }
+
   return `
     COALESCE((
-      SELECT ${isArraySelection ? `JSON_ARRAYAGG(JSON_OBJECT(${selectList}))` : `JSON_OBJECT(${selectList})`} ${fromClause} ${orderByClause} ${whereClause} ${paginationClause ? ` ${paginationClause}` : ""}
+      SELECT ${isArraySelection ? `JSON_ARRAYAGG(JSON_OBJECT(${selectList}))` : `JSON_OBJECT(${selectList})`} ${fromClause} ${whereClause} ${orderByClause}${withoutArrayWrapper ? " LIMIT 1" : ""}
     ), ${isArraySelection ? "JSON_ARRAY()" : "null"})
   `;
 };

package/src/databases/engines/postgresql/query/index.ts

@@ -18,6 +18,8 @@ import {
   processFieldSelectionsPG,
 } from "../../../common";
 
+import { applyDirectives } from "../../../directives";
+
 // Generate CTE for aggregations
 const buildAggregationCTE = (
   groupByInfo: GroupByInfo,
@@ -58,6 +60,7 @@ const buildAggregationCTE = (
 // Build the main query for grouped results
 const buildGroupedQuery = (
   entities: MergedEntities,
+  variablesDefinition: VariableDefinition[],
   field: SelectionAnalysis,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
@@ -72,7 +75,15 @@ const buildGroupedQuery = (
   if (hasKey) {
     // Add key object with group by fields
     const keyFields = keys
-      .map((key) => `'${key.alias || key.name}', ${cteAlias}."${key.name}"`)
+      .map((key) => {
+        const selector = applyDirectives(
+          `${cteAlias}."${key.name}"`,
+          key.directives,
+          "pg",
+          variablesDefinition,
+        );
+        return `'${key.alias || key.name}', ${selector}`;
+      })
       .join(", ");
 
     selectClauses.push(`'${keyResolved}', json_build_object(${keyFields})`);
@@ -96,7 +107,15 @@ const buildGroupedQuery = (
     if (itemsSelection?.selections) {
       const itemFields = itemsSelection.selections
         .filter((sel) => !isAggregationField(sel.name) && sel.name !== "items")
-        .map((sel) => `'${sel.alias || sel.name}', ${tableAlias}."${sel.name}"`)
+        .map((sel) => {
+          const selector = applyDirectives(
+            `${tableAlias}."${sel.name}"`,
+            sel.directives,
+            "pg",
+            variablesDefinition,
+          );
+          return `'${sel.alias || sel.name}', ${selector}`;
+        })
         .join(", ");
 
       if (itemFields) {
@@ -240,6 +259,7 @@ export const buildSQLForField = (
     // Handle GROUP BY aggregation query
     const mainQuery = buildGroupedQuery(
       entities,
+      variablesDefinition,
       field,
       groupByInfo,
       dottedQuotedName,
@@ -280,6 +300,24 @@ export const buildSQLForField = (
 
   const isArraySelection = !!field.isArray && !withoutArrayWrapper;
 
+  // json_agg collapses the rows into one, so LIMIT/OFFSET applied next to it
+  // trims aggregate rows rather than table rows: the limit does nothing and any
+  // non-zero offset skips the only row there is. Paginate inside a derived table
+  // and aggregate that. ROW_NUMBER over the same ordering carries the order out
+  // to the aggregate, which PostgreSQL does not otherwise guarantee.
+  if (isArraySelection && paginationClause) {
+    const pageAlias = `${tableAlias}_page`;
+
+    return `
+    COALESCE((
+      SELECT json_agg(${pageAlias}.obj ORDER BY ${pageAlias}.__ord)
+      FROM (
+        SELECT json_build_object(${selectList}) AS obj, ROW_NUMBER() OVER (${orderByClause}) AS __ord ${fromClause} ${whereClause} ${orderByClause} ${paginationClause}
+      ) ${pageAlias}
+    ), '[]'::json)
+  `;
+  }
+
   return `
     COALESCE((
       SELECT ${isArraySelection ? `json_agg(json_build_object(${selectList}) ${orderByClause})` : `json_build_object(${selectList})`} ${fromClause} ${whereClause} ${withoutArrayWrapper ? " LIMIT 1" : ""} ${paginationClause ? ` ${paginationClause}` : ""}

package/src/databases/sqlTypeUtils.ts

@@ -27,7 +27,6 @@ export const categorizeSqlType = (dataType: string): SqlTypeCategory => {
     lowerType === "bigint" ||
     lowerType === "tinyint" ||
     lowerType === "mediumint" ||
-    lowerType === "numeric" ||
     lowerType === "number"
   ) {
     return SqlTypeCategory.INTEGER;
@@ -40,6 +39,9 @@ export const categorizeSqlType = (dataType: string): SqlTypeCategory => {
     lowerType === "double" ||
     lowerType === "double precision" ||
     lowerType === "decimal" ||
+    // PostgreSQL's information_schema reports DECIMAL(p, s) as "numeric", so
+    // classifying it as an integer typed every PG decimal column as GraphQL Int.
+    lowerType === "numeric" ||
     lowerType === "money" ||
     lowerType === "smallmoney"
   ) {

package/src/subscriptions/strategies/index.ts

@@ -14,7 +14,7 @@ export const createSubscriptionStrategyRegistry = (): SubscriptionStrategyRegist
   const queueStrategy = createQueueSubscriptionStrategy();
 
   registry.set(EntitySource.TABLE, databaseStrategy);
-  registry.set(EntitySource.QUEUE_PUBLISHER, queueStrategy);
+  registry.set(EntitySource.QUEUE_SUBSCRIBER, queueStrategy);
 
   return registry;
 };

package/src/subscriptions/strategies/queue.ts

@@ -23,7 +23,7 @@ const buildCompositeKey = (context: SubscriptionContext): string => {
  * - This strategy manages connection registration with the event emitter
  */
 export const createQueueSubscriptionStrategy = (): SubscriptionStrategy => ({
-  source: EntitySource.QUEUE_PUBLISHER,
+  source: EntitySource.QUEUE_SUBSCRIBER,
 
   getSubscriptionKey(context) {
     return buildCompositeKey(context);

package/src/types/resolver.ts

@@ -1,6 +1,6 @@
 import type { RemoteRESTResolved, RemoteRESTRoute } from "../remoteREST/types";
 import type { RemoteSchemaResolved } from "../remoteSchemas/types";
-import type { Publisher } from "./configuration";
+import type { Publisher, Subscriber } from "./configuration";
 import type { ProcedureResolver, TableResolver } from "./db";
 import type { TypedOperation } from "./zod/operation";
 
@@ -14,6 +14,8 @@ export enum EntitySource {
   STORED_PROCEDURE = "stored_procedure",
   /** Message queue (RabbitMQ, Kafka, etc.) */
   QUEUE_PUBLISHER = "queue_publisher",
+  /** Message queue subscriber (exposed as a GraphQL subscription) */
+  QUEUE_SUBSCRIBER = "queue_subscriber",
   /** Authentication mutations (login, refresh, etc.) */
   AUTH = "auth",
   /** Custom operation handlers */
@@ -57,6 +59,14 @@ export type QueueResolverEntry = ResolverEntryBase & {
   resolver: Publisher;
 };
 
+/**
+ * Resolver entry for message queue subscribers
+ */
+export type QueueSubscriberResolverEntry = ResolverEntryBase & {
+  source: EntitySource.QUEUE_SUBSCRIBER;
+  resolver: Subscriber;
+};
+
 /**
  * Resolver entry for authentication operations
  */
@@ -114,6 +124,7 @@ export type ResolverEntry =
   | TableResolverEntry
   | StoredProcedureResolverEntry
   | QueueResolverEntry
+  | QueueSubscriberResolverEntry
   | AuthResolverEntry
   | OperationResolverEntry
   | RemoteSchemaResolverEntry
@@ -144,6 +155,11 @@ export const createResolverEntry = {
     resolver,
   }),
 
+  queueSubscriber: (resolver: Subscriber): QueueSubscriberResolverEntry => ({
+    source: EntitySource.QUEUE_SUBSCRIBER,
+    resolver,
+  }),
+
   auth: (
     name: string,
     operation: AuthResolverEntry["resolver"]["operation"],

package/src/types/zod/configuration.ts

@@ -11,7 +11,7 @@ import { RemoteRESTConfigZod } from "./remoteREST";
 import { RemoteSchemaConfigZod } from "./remoteSchema";
 
 export const ConfigurationZod = z
-  .object({
+  .strictObject({
     name: z.string(),
     version: z.string(),
     tokenStrategy: TokenStrategyZod.optional().default("jwt"),