bunsane 0.1.4 → 0.2.0

package/endpoints/tables.ts

@@ -0,0 +1,212 @@
+import db from "../database";
+import type {
+    StudioTableQueryParams,
+    StudioTableResponse,
+    DeleteTableRowsRequest,
+    DeleteResponse,
+    TableColumn,
+    TableRowData,
+} from "./types";
+
+export async function handleStudioTableRequest(
+    tableName: string,
+    params: StudioTableQueryParams = {}
+): Promise<Response> {
+    const limit = Math.min(Math.max(params.limit ?? 50, 1), 1000);
+    const offset = Math.max(params.offset ?? 0, 0);
+    const searchTerm = params.search ?? "";
+
+    try {
+        const columnsResult = await db`
+            SELECT 
+                column_name,
+                data_type,
+                is_nullable,
+                column_default
+            FROM information_schema.columns
+            WHERE table_name = ${tableName}
+            AND table_schema = 'public'
+            ORDER BY ordinal_position
+        `;
+
+        if (columnsResult.length === 0) {
+            return new Response(
+                JSON.stringify({ error: `Table '${tableName}' not found` }),
+                {
+                    status: 404,
+                    headers: { "Content-Type": "application/json" },
+                }
+            );
+        }
+
+        const primaryKeyResult = await db`
+            SELECT kcu.column_name
+            FROM information_schema.table_constraints tc
+            JOIN information_schema.key_column_usage kcu 
+                ON tc.constraint_name = kcu.constraint_name
+                AND tc.table_schema = kcu.table_schema
+            WHERE tc.constraint_type = 'PRIMARY KEY'
+            AND tc.table_name = ${tableName}
+            AND tc.table_schema = 'public'
+        `;
+        const primaryKeyColumns = new Set(
+            primaryKeyResult.map((row: { column_name: string }) => row.column_name)
+        );
+
+        const columns: TableColumn[] = columnsResult.map((col: {
+            column_name: string;
+            data_type: string;
+            is_nullable: string;
+        }) => ({
+            name: col.column_name,
+            type: col.data_type,
+            nullable: col.is_nullable === "YES",
+            primary: primaryKeyColumns.has(col.column_name),
+        }));
+
+        const textColumns = columnsResult
+            .filter((col: { data_type: string }) =>
+                ["character varying", "text", "varchar", "char", "uuid"].includes(col.data_type)
+            )
+            .map((col: { column_name: string }) => col.column_name);
+
+        let rows: TableRowData[];
+        let totalResult: { count: number }[];
+
+        if (searchTerm && textColumns.length > 0) {
+            const searchPattern = `%${searchTerm}%`;
+            const searchConditions = textColumns
+                .map((col: string) => `"${col}"::text ILIKE $1`)
+                .join(" OR ");
+
+            rows = await db.unsafe(
+                `SELECT * FROM "${tableName}" 
+                 WHERE ${searchConditions}
+                 ORDER BY created_at DESC NULLS LAST
+                 LIMIT $2 OFFSET $3`,
+                [searchPattern, limit, offset]
+            );
+
+            totalResult = await db.unsafe(
+                `SELECT COUNT(*) as count FROM "${tableName}" WHERE ${searchConditions}`,
+                [searchPattern]
+            );
+        } else {
+            rows = await db.unsafe(
+                `SELECT * FROM "${tableName}" 
+                 ORDER BY created_at DESC NULLS LAST
+                 LIMIT $1 OFFSET $2`,
+                [limit, offset]
+            );
+
+            totalResult = await db.unsafe(
+                `SELECT COUNT(*) as count FROM "${tableName}"`
+            );
+        }
+
+        const total = Number(totalResult[0]?.count ?? 0);
+
+        const responseData: StudioTableResponse = {
+            name: tableName,
+            columns,
+            rows,
+            total,
+            limit,
+            offset,
+        };
+
+        return new Response(JSON.stringify(responseData), {
+            headers: { "Content-Type": "application/json" },
+        });
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return new Response(
+            JSON.stringify({ error: `Failed to fetch table data: ${errorMessage}` }),
+            {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+}
+
+export async function handleStudioTableDeleteRequest(
+    tableName: string,
+    requestBody: DeleteTableRowsRequest
+): Promise<Response> {
+    const { ids } = requestBody;
+
+    if (!ids || !Array.isArray(ids) || ids.length === 0) {
+        return new Response(
+            JSON.stringify({ error: "ids array is required and must not be empty" }),
+            {
+                status: 400,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+
+    try {
+        const idPlaceholders = ids.map((_, index) => `$${index + 1}`).join(", ");
+
+        await db.unsafe(
+            `DELETE FROM "${tableName}" WHERE id IN (${idPlaceholders})`,
+            ids
+        );
+
+        const deletedCount = ids.length;
+
+        const responseData: DeleteResponse = {
+            success: true,
+            deletedCount,
+            message: `Successfully deleted ${deletedCount} row(s) from ${tableName}`,
+        };
+
+        return new Response(JSON.stringify(responseData), {
+            headers: { "Content-Type": "application/json" },
+        });
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return new Response(
+            JSON.stringify({ error: `Failed to delete rows: ${errorMessage}` }),
+            {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+}
+
+export async function handleGetTables(): Promise<Response> {
+    try {
+        // Fetch all tables except ECS tables
+        const ecsTables = ['components', 'entities', 'entity_components', 'spatial_ref_sys'];
+        const ecsTablePlaceholders = ecsTables.map((_, index) => `$${index + 1}`).join(", ");
+
+        const result = await db.unsafe(
+            `SELECT table_name
+             FROM information_schema.tables
+             WHERE table_schema = 'public'
+             AND table_type = 'BASE TABLE'
+             AND table_name NOT IN (${ecsTablePlaceholders})
+             AND table_name NOT LIKE 'components_%'
+             ORDER BY table_name`,
+            ecsTables
+        );
+
+        const tables = result.map((row: { table_name: string }) => row.table_name);
+
+        return new Response(JSON.stringify({ tables }), {
+            headers: { "Content-Type": "application/json" },
+        });
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return new Response(
+            JSON.stringify({ error: `Failed to fetch tables: ${errorMessage}` }),
+            {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    }
+}

package/endpoints/types.ts

@@ -0,0 +1,155 @@
+interface StudioTableQueryParams {
+    limit?: number;
+    offset?: number;
+    search?: string;
+}
+
+interface StudioArcheTypeQueryParams {
+    limit?: number;
+    offset?: number;
+    search?: string;
+    include_deleted?: boolean;
+}
+
+interface TableColumn {
+    name: string;
+    type: string;
+    nullable: boolean;
+    primary: boolean;
+}
+
+interface TableRowData {
+    [key: string]: unknown;
+}
+
+interface StudioTableResponse {
+    name: string;
+    columns: TableColumn[];
+    rows: TableRowData[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+
+interface ArcheTypeField {
+    fieldName: string;
+    componentName: string;
+    fieldLabel: string;
+    nullable?: boolean;
+}
+
+interface ArcheTypeEntityRecord {
+    entityId: string;
+    components: Record<string, unknown>;
+    deleted_at?: string | null;
+}
+
+interface StudioArcheTypeResponse {
+    name: string;
+    fields: ArcheTypeField[];
+    indicatorComponent: string | null;
+    entities: ArcheTypeEntityRecord[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+
+interface DeleteTableRowsRequest {
+    ids: string[];
+}
+
+interface DeleteArcheTypeEntitiesRequest {
+    entityIds: string[];
+}
+
+interface DeleteResponse {
+    success: boolean;
+    deletedCount: number;
+    message: string;
+}
+
+interface EntityComponent {
+    id: string;
+    name: string;
+    type_id: string;
+    data: unknown;
+    created_at: string;
+    updated_at: string;
+    deleted_at: string | null;
+}
+
+interface EntityInspectorResponse {
+    entity: {
+        id: string;
+        created_at: string;
+        updated_at: string;
+        deleted_at: string | null;
+    };
+    components: EntityComponent[];
+}
+
+interface ComponentTypeStats {
+    name: string;
+    count: number;
+}
+
+interface ArcheTypeStats {
+    name: string;
+    entityCount: number;
+    componentCount: number;
+}
+
+interface StudioStatsResponse {
+    entities: {
+        active: number;
+        deleted: number;
+        total: number;
+    };
+    componentTypes: ComponentTypeStats[];
+    archetypes: ArcheTypeStats[];
+}
+
+interface ComponentTypeInfo {
+    name: string;
+    entityCount: number;
+    partitionTable: string;
+    fields: string[];
+}
+
+interface StudioComponentsResponse {
+    components: ComponentTypeInfo[];
+}
+
+interface StudioQueryRequest {
+    sql: string;
+}
+
+interface StudioQueryResponse {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    duration: number;
+}
+
+export type {
+    StudioTableQueryParams,
+    StudioArcheTypeQueryParams,
+    TableColumn,
+    TableRowData,
+    StudioTableResponse,
+    ArcheTypeField,
+    ArcheTypeEntityRecord,
+    StudioArcheTypeResponse,
+    DeleteTableRowsRequest,
+    DeleteArcheTypeEntitiesRequest,
+    DeleteResponse,
+    EntityComponent,
+    EntityInspectorResponse,
+    ComponentTypeStats,
+    ArcheTypeStats,
+    StudioStatsResponse,
+    ComponentTypeInfo,
+    StudioComponentsResponse,
+    StudioQueryRequest,
+    StudioQueryResponse,
+};

package/gql/ArchetypeOperations.ts

@@ -1,4 +1,4 @@
-import { getAllArchetypeSchemas, getArchetypeSchema } from "../core/ArcheType";
+import { getAllArchetypeSchemas, getArchetypeSchema, weaveAllArchetypes } from "../core/ArcheType";
 import { logger as MainLogger } from "../core/Logger";
 
 const logger = MainLogger.child({ scope: "ArchetypeOperations" });
@@ -25,9 +25,6 @@ export function generateArchetypeOperations(config: ArchetypeOperationConfig = {
         enableMutations = { create: true, update: true, delete: true }
     } = config;
 
-    const schemas = getAllArchetypeSchemas();
-    logger.trace(`getAllArchetypeSchemas returned ${schemas.length} schemas`);
-    
     let typeDefs = "\n# Auto-generated Archetype Types\n";
     const queryFields: string[] = [];
     const mutationFields: string[] = [];
@@ -36,23 +33,39 @@ export function generateArchetypeOperations(config: ArchetypeOperationConfig = {
     // Track defined types to prevent duplicates
     const definedTypes = new Set<string>();
 
-    schemas.forEach(({ zodSchema, graphqlSchema }) => {
-        // Extract archetype name from the schema
-        const archetypeName = extractArchetypeName(graphqlSchema);
-        if (!archetypeName) {
-            logger.warn(`Could not extract archetype name from schema: ${graphqlSchema.substring(0, 100)}`);
-            return;
-        }
-
-        logger.trace(`Generating operations for archetype: ${archetypeName}`);
-
-        // Add the archetype type definition (without Query/Mutation)
-        // Extract and deduplicate type definitions
-        const typeDefinitions = extractTypeDefinitions(graphqlSchema);
+    // Get the full weaved schema that includes all archetypes and their relations
+    const fullSchema = weaveAllArchetypes();
+    if (fullSchema) {
+        logger.trace(`Using full weaved schema for type definitions`);
+        // Extract and deduplicate type definitions from the full schema
+        const typeDefinitions = extractTypeDefinitions(fullSchema);
         const deduplicatedTypes = deduplicateTypeDefinitions(typeDefinitions, definedTypes);
-        logger.trace(`Adding ${deduplicatedTypes.length} characters of type definitions for ${archetypeName}`);
+        logger.trace(`Adding ${deduplicatedTypes.length} characters of type definitions`);
         typeDefs += deduplicatedTypes;
-    });
+    } else {
+        logger.warn(`No full schema available, falling back to individual schemas`);
+        // Fallback to individual schemas if weaving fails
+        const schemas = getAllArchetypeSchemas();
+        logger.trace(`getAllArchetypeSchemas returned ${schemas.length} schemas`);
+        
+        schemas.forEach(({ zodSchema, graphqlSchema }) => {
+            // Extract archetype name from the schema
+            const archetypeName = extractArchetypeName(graphqlSchema);
+            if (!archetypeName) {
+                logger.warn(`Could not extract archetype name from schema: ${graphqlSchema.substring(0, 100)}`);
+                return;
+            }
+
+            logger.trace(`Generating operations for archetype: ${archetypeName}`);
+
+            // Add the archetype type definition (without Query/Mutation)
+            // Extract and deduplicate type definitions
+            const typeDefinitions = extractTypeDefinitions(graphqlSchema);
+            const deduplicatedTypes = deduplicateTypeDefinitions(typeDefinitions, definedTypes);
+            logger.trace(`Adding ${deduplicatedTypes.length} characters of type definitions for ${archetypeName}`);
+            typeDefs += deduplicatedTypes;
+        });
+    }
 
     typeDefs += "\n# END AUTO-GENERATED TYPES\n";
     logger.trace(`Final typeDefs length: ${typeDefs.length}`);
@@ -61,73 +74,6 @@ export function generateArchetypeOperations(config: ArchetypeOperationConfig = {
     return { typeDefs, queryFields, mutationFields, resolvers };
 }
 
-/**
- * WIP
- * Generate full archetype operations including types, queries, and mutations
- */
-//TODO: Implement this
-export function generateArchetypeOperationsWithCRUD(config: ArchetypeOperationConfig = {}) {
-    const {
-        enableQueries = { get: true, list: true },
-        enableMutations = { create: true, update: true, delete: true }
-    } = config;
-
-    const schemas = getAllArchetypeSchemas();
-    let typeDefs = "\n# Auto-generated Archetype Types\n";
-    const queryFields: string[] = [];
-    const mutationFields: string[] = [];
-    const resolvers: any = { Query: {}, Mutation: {} };
-
-    schemas.forEach(({ zodSchema, graphqlSchema }) => {
-        // Extract archetype name from the schema
-        const archetypeName = extractArchetypeName(graphqlSchema);
-        if (!archetypeName) return;
-
-        logger.trace(`Generating operations for archetype: ${archetypeName}`);
-
-        // Add the archetype type definition (without Query/Mutation)
-        typeDefs += extractTypeDefinitions(graphqlSchema);
-
-        // Generate filter input type
-        typeDefs += generateFilterInput(archetypeName, zodSchema);
-
-        // Generate create input type
-        typeDefs += generateCreateInput(archetypeName, zodSchema);
-
-        // Generate update input type
-        typeDefs += generateUpdateInput(archetypeName, zodSchema);
-
-        // Generate Query operations
-        if (enableQueries?.get) {
-            queryFields.push(`get${archetypeName}(id: ID!): ${archetypeName}`);
-            resolvers.Query[`get${archetypeName}`] = createGetResolver(archetypeName);
-        }
-
-        if (enableQueries?.list) {
-            queryFields.push(`list${archetypeName}s(filter: ${archetypeName}Filter, limit: Int, offset: Int): [${archetypeName}!]!`);
-            resolvers.Query[`list${archetypeName}s`] = createListResolver(archetypeName);
-        }
-
-        // Generate Mutation operations
-        if (enableMutations?.create) {
-            mutationFields.push(`create${archetypeName}(input: Create${archetypeName}Input!): ${archetypeName}!`);
-            resolvers.Mutation[`create${archetypeName}`] = createCreateResolver(archetypeName);
-        }
-
-        if (enableMutations?.update) {
-            mutationFields.push(`update${archetypeName}(id: ID!, input: Update${archetypeName}Input!): ${archetypeName}!`);
-            resolvers.Mutation[`update${archetypeName}`] = createUpdateResolver(archetypeName);
-        }
-
-        if (enableMutations?.delete) {
-            mutationFields.push(`delete${archetypeName}(id: ID!): Boolean!`);
-            resolvers.Mutation[`delete${archetypeName}`] = createDeleteResolver(archetypeName);
-        }
-    });
-
-    return { typeDefs, queryFields, mutationFields, resolvers };
-}
-
 function extractArchetypeName(graphqlSchema: string): string | null {
     const match = graphqlSchema.match(/type (\w+) \{/);
     return match ? match[1] ?? null : null;