@0xobelisk/graphql-server 1.2.0-pre.100

package/src/plugins/all-fields-filter-plugin.ts

@@ -0,0 +1,158 @@
+import { Plugin } from 'postgraphile';
+
+// All fields filter plugin - ensure all fields support filtering
+export const AllFieldsFilterPlugin: Plugin = (builder) => {
+  // Extend filter input type, add filter support for all fields
+  builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+    const {
+      scope: { isPgConnectionFilter, pgIntrospection: table }
+    } = context;
+
+    // Only handle connection filters
+    if (!isPgConnectionFilter || !table || table.kind !== 'class') {
+      return fields;
+    }
+
+    const enhancedFields = { ...fields };
+
+    // Add filters for each field of the table
+    table.attributes.forEach((attr: any) => {
+      const fieldName = build.inflection.column(attr);
+
+      // Skip fields that already exist
+      if (enhancedFields[fieldName]) {
+        return;
+      }
+
+      // Determine filter type based on field type
+      let filterType;
+      const pgType = attr.type;
+
+      // Special handling for BigInt type
+      if (pgType.name === 'int8' || pgType.name === 'bigint') {
+        // For BigInt type, try to use StringFilter (because BigInt is represented as string in GraphQL)
+        filterType = build.getTypeByName('StringFilter');
+      } else {
+        // Map PostgreSQL types to GraphQL filter types
+        switch (pgType.category) {
+          case 'S': // String type
+            filterType = build.getTypeByName('StringFilter');
+            break;
+          case 'N': // Numeric type
+            if (pgType.name.includes('int')) {
+              filterType = build.getTypeByName('IntFilter');
+            } else {
+              filterType = build.getTypeByName('FloatFilter');
+            }
+            break;
+          case 'B': // Boolean type
+            filterType = build.getTypeByName('BooleanFilter');
+            break;
+          case 'D': // Date/time type
+            filterType = build.getTypeByName('DatetimeFilter');
+            break;
+          default:
+            // For other types, use string filter as default
+            filterType = build.getTypeByName('StringFilter');
+        }
+      }
+
+      // If specific filter type not found, use string filter
+      if (!filterType) {
+        filterType = build.getTypeByName('StringFilter');
+      }
+
+      // Add field filter
+      if (filterType) {
+        enhancedFields[fieldName] = {
+          type: filterType,
+          description: `Filter by the object's \`${attr.name}\` field.`
+        };
+      }
+    });
+
+    return enhancedFields;
+  });
+
+  // Ensure sorting options are generated for all fields
+  builder.hook('GraphQLEnumType:values', (values, build, context) => {
+    const {
+      scope: { isPgRowSortEnum, pgIntrospection: table }
+    } = context;
+
+    if (!isPgRowSortEnum || !table || table.kind !== 'class') {
+      return values;
+    }
+
+    const enhancedValues = { ...values };
+
+    // Add ASC and DESC sorting options for each field
+    table.attributes.forEach((attr: any) => {
+      const columnName = build.inflection.column(attr);
+      const enumName = build.inflection.constantCase(columnName);
+
+      // Add ascending sort
+      const ascKey = `${enumName}_ASC`;
+      if (!enhancedValues[ascKey]) {
+        enhancedValues[ascKey] = {
+          value: {
+            alias: `${attr.name.toLowerCase()}_ASC`,
+            specs: [[attr.name, true]]
+          },
+          description: `Sorts by ${attr.name} in ascending order.`
+        };
+      }
+
+      // Add descending sort
+      const descKey = `${enumName}_DESC`;
+      if (!enhancedValues[descKey]) {
+        enhancedValues[descKey] = {
+          value: {
+            alias: `${attr.name.toLowerCase()}_DESC`,
+            specs: [[attr.name, false]]
+          },
+          description: `Sorts by ${attr.name} in descending order.`
+        };
+      }
+    });
+
+    return enhancedValues;
+  });
+
+  // Extend condition filters to support all fields
+  builder.hook('GraphQLInputObjectType:fields', (fields, build, context) => {
+    const {
+      scope: { isPgCondition, pgIntrospection: table }
+    } = context;
+
+    if (!isPgCondition || !table || table.kind !== 'class') {
+      return fields;
+    }
+
+    const enhancedFields = { ...fields };
+
+    // Add condition filters for each field
+    table.attributes.forEach((attr: any) => {
+      const fieldName = build.inflection.column(attr);
+
+      // Skip fields that already exist
+      if (enhancedFields[fieldName]) {
+        return;
+      }
+
+      // Get GraphQL type
+      const gqlType = build.pgGetGqlTypeByTypeIdAndModifier(attr.typeId, attr.typeModifier);
+
+      if (gqlType) {
+        enhancedFields[fieldName] = {
+          type: gqlType,
+          description: `Checks for equality with the object's \`${attr.name}\` field.`
+        };
+      }
+    });
+
+    return enhancedFields;
+  });
+};
+
+export default AllFieldsFilterPlugin;

package/src/plugins/database-introspector.ts

@@ -0,0 +1,126 @@
+import { Pool } from 'pg';
+
+// Database table structure interface
+export interface TableField {
+  field_name: string;
+  field_type: string;
+  field_index: number | null;
+  is_key: boolean;
+}
+
+export interface DynamicTable {
+  table_name: string;
+  fields: TableField[];
+}
+
+// Scan database table structure
+export class DatabaseIntrospector {
+  constructor(private pool: Pool, private schema: string = 'public') {}
+
+  // Get all dynamically created store_* tables
+  async getStoreTables(): Promise<string[]> {
+    const result = await this.pool.query(
+      `
+			SELECT table_name 
+			FROM information_schema.tables 
+			WHERE table_schema = $1 
+				AND table_name LIKE 'store_%'
+			ORDER BY table_name
+		`,
+      [this.schema]
+    );
+
+    return result.rows.map((row) => row.table_name);
+  }
+
+  // Get system tables (dubhe related tables)
+  async getSystemTables(): Promise<string[]> {
+    const result = await this.pool.query(
+      `
+			SELECT table_name 
+			FROM information_schema.tables 
+			WHERE table_schema = $1 
+				AND (table_name = 'table_fields')
+			ORDER BY table_name
+		`,
+      [this.schema]
+    );
+
+    return result.rows.map((row) => row.table_name);
+  }
+
+  // Get dynamic table field information from table_fields table
+  async getDynamicTableFields(tableName: string): Promise<TableField[]> {
+    // Extract table name (remove store_ prefix)
+    const baseTableName = tableName.replace('store_', '');
+
+    const result = await this.pool.query(
+      `
+			SELECT field_name, field_type, field_index, is_key
+			FROM table_fields 
+			WHERE table_name = $1
+			ORDER BY is_key DESC, field_index ASC
+		`,
+      [baseTableName]
+    );
+
+    return result.rows;
+  }
+
+  // Get field information from system tables
+  async getSystemTableFields(tableName: string): Promise<TableField[]> {
+    const result = await this.pool.query(
+      `
+			SELECT 
+				column_name as field_name,
+				data_type as field_type,
+				ordinal_position as field_index,
+				CASE WHEN column_name = 'entity_id' THEN true ELSE false END as is_key
+			FROM information_schema.columns 
+			WHERE table_schema = $1 AND table_name = $2
+			ORDER BY ordinal_position
+		`,
+      [this.schema, tableName]
+    );
+
+    return result.rows;
+  }
+
+  // Get complete information for all tables
+  async getAllTables(): Promise<DynamicTable[]> {
+    const storeTables = await this.getStoreTables();
+    const systemTables = await this.getSystemTables();
+    const allTables: DynamicTable[] = [];
+
+    // Process dynamic tables
+    for (const tableName of storeTables) {
+      const fields = await this.getDynamicTableFields(tableName);
+      allTables.push({
+        table_name: tableName,
+        fields
+      });
+    }
+
+    // Process system tables
+    for (const tableName of systemTables) {
+      const fields = await this.getSystemTableFields(tableName);
+      allTables.push({
+        table_name: tableName,
+        fields
+      });
+    }
+
+    return allTables;
+  }
+
+  // Test database connection
+  async testConnection(): Promise<boolean> {
+    try {
+      await this.pool.query('SELECT NOW() as current_time');
+      return true;
+    } catch (error) {
+      console.error('Database connection test failed:', error);
+      return false;
+    }
+  }
+}

package/src/plugins/enhanced-playground.ts

@@ -0,0 +1,121 @@
+// Enhanced GraphQL Playground plugin
+// Provides better visual experience based on GraphiQL and Explorer plugin
+
+import type { IncomingMessage, ServerResponse } from 'http';
+
+export interface PlaygroundOptions {
+  url: string;
+  subscriptionUrl?: string;
+  title?: string;
+  subtitle?: string;
+}
+
+export function createEnhancedPlayground(
+  options: PlaygroundOptions
+): (req: IncomingMessage, res: ServerResponse, config?: any) => string {
+  return (_req: IncomingMessage, _res: ServerResponse, _config?: any) => {
+    // This content is sourced from https://github.com/graphql/graphiql/blob/main/examples/graphiql-cdn/index.html
+    return `<!--
+             *  Copyright (c) 2025 GraphQL Contributors
+             *  All rights reserved.
+             *
+             *  This source code is licensed under the license found in the
+             *  LICENSE file in the root directory of this source tree.
+            -->
+            <!doctype html>
+            <html lang="en">
+              <head>
+                <meta charset="UTF-8" />
+                <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+                <title>GraphiQL 5 with React 19 and GraphiQL Explorer</title>
+                <style>
+                  body {
+                    margin: 0;
+                  }
+
+                  #graphiql {
+                    height: 100dvh;
+                  }
+
+                  .loading {
+                    height: 100%;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    font-size: 4rem;
+                  }
+                </style>
+                <link rel="stylesheet" href="https://esm.sh/graphiql/dist/style.css" />
+                <link
+                  rel="stylesheet"
+                  href="https://esm.sh/@graphiql/plugin-explorer/dist/style.css"
+                />
+                <!-- Note: the ?standalone flag bundles the module along with all of its 'dependencies', excluding peerDependencies', into a single JavaScript file. -->
+                <script type="importmap">
+                  {
+                    "imports": {
+                      "react": "https://esm.sh/react@19.1.0",
+                      "react/jsx-runtime": "https://esm.sh/react@19.1.0/jsx-runtime",
+
+                      "react-dom": "https://esm.sh/react-dom@19.1.0",
+                      "react-dom/client": "https://esm.sh/react-dom@19.1.0/client",
+
+                      "graphiql": "https://esm.sh/graphiql?standalone&external=react,react-dom,@graphiql/react,graphql",
+                      "@graphiql/plugin-explorer": "https://esm.sh/@graphiql/plugin-explorer?standalone&external=react,@graphiql/react,graphql",
+                      "@graphiql/react": "https://esm.sh/@graphiql/react?standalone&external=react,react-dom,graphql",
+
+                      "@graphiql/toolkit": "https://esm.sh/@graphiql/toolkit?standalone&external=graphql",
+                      "graphql": "https://esm.sh/graphql@16.11.0"
+                    }
+                  }
+                </script>
+                <script type="module">
+                  // Import React and ReactDOM
+                  import React from 'react';
+                  import ReactDOM from 'react-dom/client';
+                  // Import GraphiQL and the Explorer plugin
+                  import { GraphiQL, HISTORY_PLUGIN } from 'graphiql';
+                  import { createGraphiQLFetcher } from '@graphiql/toolkit';
+                  import { explorerPlugin } from '@graphiql/plugin-explorer';
+
+                  import createJSONWorker from 'https://esm.sh/monaco-editor/esm/vs/language/json/json.worker.js?worker';
+                  import createGraphQLWorker from 'https://esm.sh/monaco-graphql/esm/graphql.worker.js?worker';
+                  import createEditorWorker from 'https://esm.sh/monaco-editor/esm/vs/editor/editor.worker.js?worker';
+
+                  globalThis.MonacoEnvironment = {
+                    getWorker(_workerId, label) {
+                      console.info('MonacoEnvironment.getWorker', { label });
+                      switch (label) {
+                        case 'json':
+                          return createJSONWorker();
+                        case 'graphql':
+                          return createGraphQLWorker();
+                      }
+                      return createEditorWorker();
+                    },
+                  };
+
+                  const fetcher = createGraphiQLFetcher(${JSON.stringify(options)});
+                  const plugins = [HISTORY_PLUGIN, explorerPlugin()];
+
+                  function App() {
+                    return React.createElement(GraphiQL, {
+                      fetcher,
+                      plugins,
+                      defaultEditorToolsVisibility: true,
+                    });
+                  }
+
+                  const container = document.getElementById('graphiql');
+                  const root = ReactDOM.createRoot(container);
+                  root.render(React.createElement(App));
+                </script>
+              </head>
+              <body>
+                <div id="graphiql">
+                  <div class="loading">Loading…</div>
+                </div>
+              </body>
+            </html>`;
+  };
+}