@0xobelisk/graphql-server 1.2.0-pre.118 → 1.2.0-pre.120

package/src/plugins/database-introspector.ts

@@ -13,34 +13,133 @@ export interface DynamicTable {
   fields: TableField[];
 }
 
+/**
+ * Maps system table name → store_dubhe_* view name.
+ * Views are created with store_dubhe_ prefix so PostGraphile discovers them
+ * automatically via the store_* scan, and SimpleNamingPlugin strips `store`
+ * to produce dubhe-prefixed GraphQL field names (e.g. dubheMarketplaceListings).
+ * The dubhe_ segment guarantees no collision with user-defined store_* tables.
+ */
+const SYSTEM_TABLE_VIEWS: Record<string, string> = {
+  marketplace_listings: 'store_dubhe_marketplace_listings',
+  sessions: 'store_dubhe_sessions',
+  user_storages: 'store_dubhe_user_storages',
+  dapp_runtime_state: 'store_dubhe_dapp_runtime_state',
+  dapp_marketplace_fees: 'store_dubhe_dapp_marketplace_fees',
+  dapp_fee_state: 'store_dubhe_dapp_fee_state',
+  dapp_revenue_state: 'store_dubhe_dapp_revenue_state',
+  object_storages: 'store_dubhe_object_storages',
+  object_storage_fields: 'store_dubhe_object_storage_fields',
+  scene_storages: 'store_dubhe_scene_storages',
+  scene_storage_fields: 'store_dubhe_scene_storage_fields',
+  scene_permits: 'store_dubhe_scene_permits',
+  scene_permit_participants: 'store_dubhe_scene_permit_participants',
+  storage_schemas: 'store_dubhe_storage_schemas',
+  storage_schema_fields: 'store_dubhe_storage_schema_fields'
+  // table_fields is already discovered by getStoreTables via store_* but exposed
+  // differently; skip it here to avoid a duplicate view.
+};
+
+/**
+ * Pre-computed JOIN views that are already created by create_indexer_tables_sql().
+ * These views live in the database as first-class objects (not SELECT * aliases),
+ * so we only need to verify they exist and expose them to PostGraphile – no DDL here.
+ *
+ * Naming follows the same store_dubhe_* convention so PostGraphile picks them up
+ * automatically alongside the plain system-table views above.
+ */
+const JOIN_VIEWS: string[] = [
+  'store_dubhe_listing_with_fees', // marketplace_listings ⋈ dapp_marketplace_fees
+  'store_dubhe_object_with_fields', // object_storages ⋈ object_storage_fields (JSONB)
+  'store_dubhe_user_with_session', // user_storages ⋈ sessions (active only)
+  'store_dubhe_scene_with_permit' // scene_storages ⋈ scene_permits
+];
+
 // 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]
-    );
+  /**
+   * Create store_dubhe_* views for all Dubhe system tables that exist in the DB.
+   * Safe to call on every startup (uses CREATE OR REPLACE VIEW).
+   * PostGraphile discovers these views exactly like regular store_* tables.
+   *
+   * Also verifies that the pre-computed JOIN views (created by create_indexer_tables_sql)
+   * are present, and logs a warning when any are missing so operators know to re-run
+   * the indexer migration.
+   */
+  async ensureSystemViews(): Promise<void> {
+    const created: string[] = [];
+    for (const [sourceTable, viewName] of Object.entries(SYSTEM_TABLE_VIEWS)) {
+      try {
+        const exists = await this.pool.query(
+          `SELECT 1 FROM information_schema.tables
+           WHERE table_schema = $1 AND table_name = $2`,
+          [this.schema, sourceTable]
+        );
+        if (exists.rows.length === 0) continue;
+
+        // Check if view already exists to avoid spammy CREATE OR REPLACE logs
+        const viewExists = await this.pool.query(
+          `SELECT 1 FROM information_schema.views
+           WHERE table_schema = $1 AND table_name = $2`,
+          [this.schema, viewName]
+        );
+        const isNew = viewExists.rows.length === 0;
+
+        await this.pool.query(
+          `CREATE OR REPLACE VIEW ${this.schema}.${viewName} AS SELECT * FROM ${this.schema}.${sourceTable}`
+        );
+
+        if (isNew) {
+          created.push(viewName);
+          console.log(`[introspector] ✨ new system view created: ${viewName} → ${sourceTable}`);
+        }
+      } catch (err) {
+        console.warn(`[introspector] could not create view ${viewName}:`, err);
+      }
+    }
+    if (created.length > 0) {
+      console.log(
+        `[introspector] watchPg will now auto-refresh GraphQL schema for: ${created.join(', ')}`
+      );
+    }
 
-    return result.rows.map((row) => row.table_name);
+    // Verify pre-computed JOIN views (created by create_indexer_tables_sql, not here).
+    const missingJoinViews: string[] = [];
+    for (const viewName of JOIN_VIEWS) {
+      try {
+        const viewExists = await this.pool.query(
+          `SELECT 1 FROM information_schema.views
+           WHERE table_schema = $1 AND table_name = $2`,
+          [this.schema, viewName]
+        );
+        if (viewExists.rows.length === 0) {
+          missingJoinViews.push(viewName);
+        } else {
+          console.log(`[introspector] ✅ join view ready: ${viewName}`);
+        }
+      } catch (err) {
+        console.warn(`[introspector] could not verify join view ${viewName}:`, err);
+      }
+    }
+    if (missingJoinViews.length > 0) {
+      console.warn(
+        `[introspector] ⚠️  missing join views (re-run indexer migration to create them): ${missingJoinViews.join(
+          ', '
+        )}`
+      );
+    }
   }
 
-  // Get system tables (dubhe related tables)
-  async getSystemTables(): Promise<string[]> {
+  // Get all dynamically created store_* tables (includes store_dubhe_* views)
+  async getStoreTables(): Promise<string[]> {
     const result = await this.pool.query(
       `
 			SELECT table_name 
 			FROM information_schema.tables 
 			WHERE table_schema = $1 
-				AND (table_name = 'table_fields')
+				AND table_name LIKE 'store_%'
 			ORDER BY table_name
 		`,
       [this.schema]
@@ -51,8 +150,8 @@ export class DatabaseIntrospector {
 
   // 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_', '');
+    // For store_dubhe_* views, look up the underlying table name
+    const baseTableName = tableName.replace(/^store_dubhe_/, '').replace(/^store_/, '');
 
     const result = await this.pool.query(
       `
@@ -64,10 +163,16 @@ export class DatabaseIntrospector {
       [baseTableName]
     );
 
+    // If no schema metadata found (system tables don't register in table_fields),
+    // fall back to reading columns from information_schema
+    if (result.rows.length === 0) {
+      return this.getSystemTableFields(tableName);
+    }
+
     return result.rows;
   }
 
-  // Get field information from system tables
+  // Get field information directly from information_schema (used for system tables)
   async getSystemTableFields(tableName: string): Promise<TableField[]> {
     const result = await this.pool.query(
       `
@@ -89,25 +194,11 @@ export class DatabaseIntrospector {
   // 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
-      });
+      allTables.push({ table_name: tableName, fields });
     }
 
     return allTables;

package/src/plugins/postgraphile-config.ts

@@ -68,8 +68,9 @@ export function createPostGraphileConfig(options: PostGraphileConfigOptions) {
     // Enable query execution plan explanation (development environment only)
     allowExplain: nodeEnv === 'development',
 
-    // Monitor PostgreSQL changes (development environment only)
-    watchPg: nodeEnv === 'development',
+    // Monitor PostgreSQL schema changes — always enabled so PostGraphile auto-rebuilds
+    // its GraphQL schema when store_dubhe_* views are created by the background poller.
+    watchPg: true,
 
     // GraphQL query timeout setting
     queryTimeout: options.queryTimeout,

package/src/plugins/simple-naming.ts

@@ -23,43 +23,44 @@ export const SimpleNamingPlugin: Plugin = (builder) => {
     originalFieldNames.forEach((fieldName) => {
       let newFieldName = fieldName;
 
-      // Remove "all" prefix, but keep system fields
-      if (
-        fieldName.startsWith('all') &&
-        !['allRows', 'allTableFields'].includes(fieldName) // Extend reserved list
-      ) {
-        // allStoreAccounts -> storeAccounts
-        // allStoreEncounters -> storeEncounters
+      // Step 1: Remove "all" prefix
+      if (fieldName.startsWith('all') && !['allRows', 'allTableFields'].includes(fieldName)) {
         newFieldName = fieldName.replace(/^all/, '');
-        // First letter to lowercase, maintain camelCase
         if (newFieldName.length > 0) {
           newFieldName = newFieldName.charAt(0).toLowerCase() + newFieldName.slice(1);
         }
       }
 
-      // Remove "store" prefix (note lowercase s, because it's already processed above)
+      // Step 2: Routing by table origin
       if (newFieldName.startsWith('store') && newFieldName !== 'store') {
-        // storeAccounts -> accounts
-        // storeAccount -> account
-        // storeEncounters -> encounters
-        // storeEncounter -> encounter
+        // User-defined store_* tables: strip "store" prefix
+        // storeWheat -> wheat, storeFarmPlots -> farmPlots
         const withoutStore = newFieldName.replace(/^store/, '');
-        // First letter to lowercase, maintain camelCase
         if (withoutStore.length > 0) {
-          const finalName = withoutStore.charAt(0).toLowerCase() + withoutStore.slice(1);
-
-          // Check if field name conflict will occur
-          if (!renamedFields[finalName] && !originalFieldNames.includes(finalName)) {
-            newFieldName = finalName;
+          const candidate = withoutStore.charAt(0).toLowerCase() + withoutStore.slice(1);
+          if (!renamedFields[candidate] && !originalFieldNames.includes(candidate)) {
+            newFieldName = candidate;
           }
-          // If conflict, keep original name (remove all but keep store)
+          // If conflict, keep the name without store strip (keeps "storeXxx")
+        }
+      } else if (newFieldName.startsWith('dubhe') && newFieldName !== 'dubhe') {
+        // Tables already prefixed with dubhe_ keep their name as-is:
+        // allDubheEvents -> dubheEvents  (no change needed)
+      } else if (newFieldName !== fieldName) {
+        // System tables (non store_*, non dubhe_*): add "dubhe" namespace prefix
+        // to prevent conflicts with any future user store_* table.
+        // sessions -> dubheSessions, userStorages -> dubheUserStorages,
+        // marketplaceListings -> dubheMarketplaceListings
+        const candidate = 'dubhe' + newFieldName.charAt(0).toUpperCase() + newFieldName.slice(1);
+        if (!renamedFields[candidate] && !originalFieldNames.includes(candidate)) {
+          newFieldName = candidate;
         }
       }
 
-      // Check if final field name will conflict
+      // Guard: if the final name still collides, fall back to original
       if (renamedFields[newFieldName]) {
         console.warn(`⚠️ Field name conflict: ${newFieldName}, keeping original name ${fieldName}`);
-        newFieldName = fieldName; // Keep original name to avoid conflict
+        newFieldName = fieldName;
       }
 
       renameMap[fieldName] = newFieldName;
@@ -94,7 +95,6 @@ export const SimpleNamingPlugin: Plugin = (builder) => {
         'Final:',
         finalFieldNames.length
       );
-      // If fields are lost, return original fields to avoid breakage
       return fields;
     }
 

package/src/server.ts

@@ -148,6 +148,9 @@ export const startServer = async (config: ServerConfig): Promise<void> => {
     }
     dbLogger.info('Database connection successful', { schema: PG_SCHEMA });
 
+    // Ensure store_dubhe_* views exist for all Dubhe system tables
+    await introspector.ensureSystemViews();
+
     const allTables = await introspector.getAllTables();
     const tableNames = allTables.map((t) => t.table_name);
 
@@ -243,6 +246,21 @@ export const startServer = async (config: ServerConfig): Promise<void> => {
     // 9. Start Express server
     await serverManager.startServer();
 
+    // 10. Background poller: re-run ensureSystemViews() every 30 s so that
+    //     store_dubhe_* views are created as soon as the indexer creates the
+    //     underlying system tables (marketplace_listings, sessions, etc.).
+    //     watchPg (enabled above) then detects the new DDL and rebuilds the
+    //     PostGraphile GraphQL schema automatically — no manual restart needed.
+    const VIEW_POLL_INTERVAL_MS = 30_000;
+    const viewPoller = setInterval(async () => {
+      try {
+        await introspector.ensureSystemViews();
+      } catch (err) {
+        dbLogger.warn('Background ensureSystemViews() failed (will retry)', { err });
+      }
+    }, VIEW_POLL_INTERVAL_MS);
+    viewPoller.unref(); // Don't keep the process alive solely for this timer
+
     logPerformance('Express server startup', startTime, {
       port: PORT,
       tableCount: allTables.length,