@graphoria/server 0.1.5 → 0.2.1

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

@@ -16,22 +16,28 @@ import {
   isAggregationField,
   isSingleQuery,
   processFieldSelectionsPG,
+  sqlColumnName,
 } from "../../../common";
 
+import { applyDirectives } from "../../../directives";
+
 // Generate CTE for aggregations
 const buildAggregationCTE = (
+  entities: MergedEntities,
+  tableName: string,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
   tableAlias: string,
   whereClause: string,
 ): string => {
   const { groupByFields, aggregations, cteAlias } = groupByInfo;
+  const sqlName = (fieldName: string) => sqlColumnName(entities, tableName, fieldName);
 
   const selectClauses: string[] = [];
 
   // Add group by fields
   groupByFields.forEach((field) => {
-    selectClauses.push(`${tableAlias}."${field}"`);
+    selectClauses.push(`${tableAlias}."${sqlName(field)}"`);
   });
 
   // Add aggregations
@@ -40,11 +46,11 @@ const buildAggregationCTE = (
       selectClauses.push(`COUNT(*) AS ${agg.alias}`);
     } else {
       const func = agg.name.toUpperCase();
-      selectClauses.push(`${func}(${tableAlias}."${agg.fieldName}") AS ${agg.alias}`);
+      selectClauses.push(`${func}(${tableAlias}."${sqlName(agg.fieldName)}") AS ${agg.alias}`);
     }
   });
 
-  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}."${field}"`).join(", ")}`;
+  const groupByClause = `GROUP BY ${groupByFields.map((field) => `${tableAlias}."${sqlName(field)}"`).join(", ")}`;
 
   return `${cteAlias} AS (
     SELECT
@@ -58,6 +64,7 @@ const buildAggregationCTE = (
 // Build the main query for grouped results
 const buildGroupedQuery = (
   entities: MergedEntities,
+  variablesDefinition: VariableDefinition[],
   field: SelectionAnalysis,
   groupByInfo: GroupByInfo,
   dottedQuotedName: string,
@@ -67,12 +74,22 @@ const buildGroupedQuery = (
   const { groupByFields, aggregations, hasItems, keyResolved, hasKey, keys, cteAlias } =
     groupByInfo;
 
+  const sqlName = (fieldName: string) => sqlColumnName(entities, field.name, fieldName);
+
   const selectClauses: string[] = [];
 
   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}."${sqlName(key.name)}"`,
+          key.directives,
+          "pg",
+          variablesDefinition,
+        );
+        return `'${key.alias || key.name}', ${selector}`;
+      })
       .join(", ");
 
     selectClauses.push(`'${keyResolved}', json_build_object(${keyFields})`);
@@ -96,12 +113,21 @@ 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}."${sqlName(sel.name)}"`,
+            sel.directives,
+            "pg",
+            variablesDefinition,
+          );
+          return `'${sel.alias || sel.name}', ${selector}`;
+        })
         .join(", ");
 
       if (itemFields) {
         const joinConditions = groupByFields.map(
-          (field) => `${tableAlias}."${field}" = ${cteAlias}."${field}"`,
+          (groupByField) =>
+            `${tableAlias}."${sqlName(groupByField)}" = ${cteAlias}."${sqlName(groupByField)}"`,
         );
 
         const whereConditions = whereClause
@@ -171,7 +197,14 @@ export const generateSQL = (
         {},
       );
 
-      const cte = buildAggregationCTE(groupByInfo, dottedQuotedName, tableAlias, whereClause);
+      const cte = buildAggregationCTE(
+        entities,
+        field.name,
+        groupByInfo,
+        dottedQuotedName,
+        tableAlias,
+        whereClause,
+      );
       ctes.push(cte);
     }
 
@@ -240,6 +273,7 @@ export const buildSQLForField = (
     // Handle GROUP BY aggregation query
     const mainQuery = buildGroupedQuery(
       entities,
+      variablesDefinition,
       field,
       groupByInfo,
       dottedQuotedName,
@@ -280,6 +314,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/high-level-operations.ts

@@ -11,7 +11,7 @@ import type {
   TableFilter,
   VirtualColumns,
 } from "../types/configuration";
-import type { Column, ProcedureResolver, TableResolver, Tables } from "../types/db";
+import type { ProcedureResolver, TableColumn, TableResolver, Tables } from "../types/db";
 
 import { getDatabaseStructure } from "./metadata/structure";
 import { buildProcedureResolver, buildTableResolver } from "./transformers/data-transformers";
@@ -63,7 +63,7 @@ export const getDatabasesStructure = async (
 
         if (tableOverride.columns.length) {
           // Mix database columns with virtual columns from configuration
-          t.columns = [...t.columns, ...tableOverride.columns] as Column[];
+          t.columns = [...t.columns, ...tableOverride.columns] as TableColumn[];
         }
 
         if (tableOverride.relationships.length) {

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/databases/transformers/genResolverName.ts

@@ -1,3 +1,5 @@
+import { sanitizeGraphQLName } from "./graphqlName";
+
 export const genResolverName = (
   schema: string,
   name: string,
@@ -12,7 +14,5 @@ export const genResolverName = (
     .replace("{schema}", schema)
     .replace("{name}", name);
 
-  if (suffix) return `${baseName}_${suffix}`;
-
-  return baseName;
+  return sanitizeGraphQLName(suffix ? `${baseName}_${suffix}` : baseName);
 };

package/src/databases/transformers/graphqlName.ts

@@ -0,0 +1,28 @@
+/**
+ * Maps a SQL identifier onto a legal GraphQL name (`/^[_A-Za-z][_0-9A-Za-z]*$/`).
+ *
+ * PostgreSQL, MySQL and SQL Server all accept identifiers GraphQL cannot spell —
+ * spaces, accents, punctuation — and an unmapped one produces an SDL document
+ * that fails to parse, taking the whole server down at boot.
+ *
+ * A name that is already legal is returned unchanged, so this cannot rename a
+ * field in any schema that boots today. Runs of illegal characters are not
+ * collapsed, and diacritics fold to their base letter rather than being dropped,
+ * both so that distinct identifiers stay distinct as often as possible.
+ */
+export const sanitizeGraphQLName = (name: string): string => {
+  const folded = name.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  const replaced = folded.replace(/[^_0-9A-Za-z]/g, "_");
+
+  if (replaced.length === 0) return "_";
+
+  return /^[0-9]/.test(replaced) ? `_${replaced}` : replaced;
+};
+
+/**
+ * The GraphQL field a column is exposed as. Introspected columns carry a
+ * `fieldName` computed once at parse time; virtual columns come from
+ * configuration and carry only a name, so they are sanitised on the spot.
+ */
+export const columnFieldName = (column: { name: string; fieldName?: string }): string =>
+  column.fieldName ?? sanitizeGraphQLName(column.name);

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"),

package/src/types/zod/db.ts

@@ -8,6 +8,7 @@ import {
   TableRelationshipZod as TableRelationshipBaseZod,
 } from "../../config";
 import { genResolverName } from "../../databases/transformers/genResolverName";
+import { sanitizeGraphQLName } from "../../databases/transformers/graphqlName";
 
 // Re-export base types and schemas from the config module
 export type {
@@ -43,6 +44,9 @@ export const TableColumnZod = z
   })
   .transform((val) => ({
     name: val.name,
+    // The SQL identifier stays in `name`; `fieldName` is what GraphQL exposes it as.
+    // Nothing emitting SQL may read `fieldName`, nothing emitting SDL may read `name`.
+    fieldName: sanitizeGraphQLName(val.name),
     dataType: val.dataType,
     isNullable: typeof val.isNullable === "boolean" ? val.isNullable : val.isNullable === 1,
     description: val.description ?? null,