@rebasepro/server-core 0.0.1-canary.4d4fb3e

package/src/api/graphql/graphql-schema-generator.ts

@@ -0,0 +1,334 @@
+import {
+    GraphQLSchema,
+    GraphQLObjectType,
+    GraphQLString,
+    GraphQLInt,
+    GraphQLFloat,
+    GraphQLBoolean,
+    GraphQLList,
+    GraphQLNonNull,
+    GraphQLFieldConfig,
+    GraphQLInputObjectType,
+    GraphQLInputFieldConfig
+} from "graphql";
+import { DataDriver, EntityCollection, FetchCollectionProps, Property, Entity } from "@rebasepro/types";
+
+/**
+ * Lightweight GraphQL schema generator that leverages existing DataDriver
+ * No duplication - uses your existing data layer and services
+ */
+export class GraphQLSchemaGenerator {
+    private collections: EntityCollection[];
+    private driver: DataDriver;
+    private typeRegistry = new Map<string, GraphQLObjectType>();
+    private inputTypeRegistry = new Map<string, GraphQLInputObjectType>();
+
+    constructor(collections: EntityCollection[], driver: DataDriver) {
+        this.collections = collections;
+        this.driver = driver;
+    }
+
+    /**
+     * Generate complete GraphQL schema using existing DataDriver
+     */
+    generateSchema(): GraphQLSchema {
+        // Create all types first
+        this.collections.forEach(collection => {
+            this.createEntityType(collection);
+            this.createInputType(collection);
+        });
+
+        const queryType = this.createQueryType();
+        const mutationType = this.createMutationType();
+
+        return new GraphQLSchema({
+            query: queryType,
+            mutation: mutationType,
+        });
+    }
+
+    /**
+     * Create GraphQL type for an entity collection
+     */
+    private createEntityType(collection: EntityCollection): GraphQLObjectType {
+        const typeName = this.getTypeName(collection);
+
+        if (this.typeRegistry.has(typeName)) {
+            return this.typeRegistry.get(typeName)!;
+        }
+
+        const fields: Record<string, GraphQLFieldConfig<unknown, unknown>> = {};
+
+        // Add ID field
+        fields.id = {
+            type: new GraphQLNonNull(GraphQLString),
+            description: "Unique identifier",
+            resolve: (source: unknown) => (source as Entity<Record<string, unknown>>).id
+        };
+
+        // Convert properties to GraphQL fields
+        Object.entries(collection.properties).forEach(([key, property]) => {
+            if (property.type !== "relation" && key !== "id") {
+                const fieldConfig = this.convertPropertyToField(property);
+                fieldConfig.resolve = (source: unknown) => (source as Entity<Record<string, unknown>>).values?.[key];
+                fields[key] = fieldConfig;
+            }
+        });
+
+        const entityType = new GraphQLObjectType({
+            name: typeName,
+            description: collection.description || `${collection.singularName} entity`,
+            fields: () => fields
+        });
+
+        this.typeRegistry.set(typeName, entityType);
+        return entityType;
+    }
+
+    private convertPropertyToField(property: Property): GraphQLFieldConfig<unknown, unknown> {
+        let type;
+
+        switch (property.type) {
+            case "string":
+                type = GraphQLString;
+                break;
+            case "number":
+                type = GraphQLFloat;
+                break;
+            case "boolean":
+                type = GraphQLBoolean;
+                break;
+            case "date":
+                type = GraphQLString;
+                break;
+            case "array":
+                type = new GraphQLList(GraphQLString);
+                break;
+            default:
+                type = GraphQLString;
+        }
+
+        return {
+            type: property.validation?.required ? new GraphQLNonNull(type) : type,
+            description: property.name || property.description
+        };
+    }
+
+    private createInputType(collection: EntityCollection): GraphQLInputObjectType {
+        const typeName = `${this.getTypeName(collection)}Input`;
+
+        if (this.inputTypeRegistry.has(typeName)) {
+            return this.inputTypeRegistry.get(typeName)!;
+        }
+
+        const fields: Record<string, GraphQLInputFieldConfig> = {};
+
+        Object.entries(collection.properties).forEach(([key, property]) => {
+            if (property.type !== "relation") {
+                fields[key] = {
+                    type: this.convertPropertyToInputType(property)
+                };
+            }
+        });
+
+        const inputType = new GraphQLInputObjectType({
+            name: typeName,
+            description: `Input for creating/updating ${collection.singularName}`,
+            fields
+        });
+
+        this.inputTypeRegistry.set(typeName, inputType);
+        return inputType;
+    }
+
+    private convertPropertyToInputType(property: Property) {
+        switch (property.type) {
+            case "string":
+                return GraphQLString;
+            case "number":
+                return GraphQLFloat;
+            case "boolean":
+                return GraphQLBoolean;
+            case "date":
+                return GraphQLString;
+            case "array":
+                return new GraphQLList(GraphQLString);
+            default:
+                return GraphQLString;
+        }
+    }
+
+    /**
+     * Create Query type using existing DataDriver methods
+     */
+    private createQueryType(): GraphQLObjectType {
+        const fields: Record<string, GraphQLFieldConfig<unknown, unknown>> = {};
+
+        this.collections.forEach(collection => {
+            const typeName = this.getTypeName(collection);
+            const entityType = this.typeRegistry.get(typeName);
+
+            if (!entityType) return;
+
+            // Single entity query - uses existing fetchEntity
+            fields[this.getSingleQueryName(collection)] = {
+                type: entityType,
+                args: {
+                    id: { type: new GraphQLNonNull(GraphQLString) }
+                },
+                resolve: async (_, args, context: unknown) => {
+                    const ctx = context as { driver: DataDriver };
+                    const ds = ctx.driver || this.driver;
+                    const entity = await ds.fetchEntity({
+                        path: collection.slug,
+                        entityId: args.id,
+                        collection
+                    });
+                    return entity;
+                }
+            };
+
+            // List query - uses existing fetchCollection
+            fields[this.getListQueryName(collection)] = {
+                type: new GraphQLList(entityType),
+                args: {
+                    limit: { type: GraphQLInt, defaultValue: 20 },
+                    offset: { type: GraphQLInt, defaultValue: 0 },
+                    where: { type: GraphQLString },
+                    orderBy: { type: GraphQLString }
+                },
+                resolve: async (_, args, context: unknown) => {
+                    const ctx = context as { driver: DataDriver };
+                    const ds = ctx.driver || this.driver;
+                    let filter: FetchCollectionProps["filter"] | undefined;
+                    if (args.where) {
+                        try {
+                            const parsed = JSON.parse(args.where);
+                            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                                throw new Error("Filter must be a JSON object");
+                            }
+                            filter = parsed;
+                        } catch (e) {
+                            throw new Error(`Invalid 'where' filter: ${e instanceof Error ? e.message : "malformed JSON"}`);
+                        }
+                    }
+                    const entities = await ds.fetchCollection({
+                        path: collection.slug,
+                        collection,
+                        filter,
+                        limit: args.limit,
+                        startAfter: args.offset ? String(args.offset) : undefined
+                    });
+                    return entities;
+                }
+            };
+        });
+
+        return new GraphQLObjectType({
+            name: "Query",
+            fields
+        });
+    }
+
+    /**
+     * Create Mutation type using existing DataDriver methods
+     */
+    private createMutationType(): GraphQLObjectType {
+        const fields: Record<string, GraphQLFieldConfig<unknown, unknown>> = {};
+
+        this.collections.forEach(collection => {
+            const typeName = this.getTypeName(collection);
+            const entityType = this.typeRegistry.get(typeName);
+            const inputType = this.inputTypeRegistry.get(`${typeName}Input`);
+
+            if (!entityType || !inputType) return;
+
+            // Create mutation - uses existing saveEntity
+            fields[`create${typeName}`] = {
+                type: entityType,
+                args: {
+                    input: { type: new GraphQLNonNull(inputType) }
+                },
+                resolve: async (_, args, context: unknown) => {
+                    const ctx = context as { driver: DataDriver };
+                    const ds = ctx.driver || this.driver;
+                    const path = collection.slug;
+                    const entity = await ds.saveEntity({
+                        path,
+                        values: args.input,
+                        collection,
+                        status: "new"
+                    });
+                    return entity;
+                }
+            };
+
+            // Update mutation - uses existing saveEntity
+            fields[`update${typeName}`] = {
+                type: entityType,
+                args: {
+                    id: { type: new GraphQLNonNull(GraphQLString) },
+                    input: { type: new GraphQLNonNull(inputType) }
+                },
+                resolve: async (_, args, context: unknown) => {
+                    const ctx = context as { driver: DataDriver };
+                    const ds = ctx.driver || this.driver;
+                    const entity = await ds.saveEntity({
+                        path: collection.slug,
+                        entityId: args.id,
+                        values: args.input,
+                        collection,
+                        status: "existing"
+                    });
+                    return entity;
+                }
+            };
+
+            // Delete mutation - uses existing deleteEntity
+            fields[`delete${typeName}`] = {
+                type: GraphQLBoolean,
+                args: {
+                    id: { type: new GraphQLNonNull(GraphQLString) }
+                },
+                resolve: async (_, args, context: unknown) => {
+                    try {
+                        const ctx = context as { driver: DataDriver };
+                        const ds = ctx.driver || this.driver;
+                        const existingEntity = await ds.fetchEntity({
+                            path: collection.slug,
+                            entityId: args.id,
+                            collection
+                        });
+                        if (!existingEntity) return false;
+                        await ds.deleteEntity({
+                            entity: existingEntity,
+                            collection
+                        });
+                        return true;
+                    } catch {
+                        return false;
+                    }
+                }
+            };
+        });
+
+        return new GraphQLObjectType({
+            name: "Mutation",
+            fields
+        });
+    }
+
+    // Helper methods
+    private getTypeName(collection: EntityCollection): string {
+        return collection.singularName?.replace(/\s+/g, "") ||
+            collection.name.slice(0, -1).replace(/\s+/g, "");
+    }
+
+    private getSingleQueryName(collection: EntityCollection): string {
+        return this.getTypeName(collection).toLowerCase();
+    }
+
+    private getListQueryName(collection: EntityCollection): string {
+        return collection.slug;
+    }
+}

package/src/api/graphql/index.ts

@@ -0,0 +1,2 @@
+export * from "./graphql-schema-generator";
+

package/src/api/index.ts

@@ -0,0 +1,11 @@
+/**
+ * API generation infrastructure for Rebase
+ * Automatically generates GraphQL and REST APIs from EntityCollection definitions
+ */
+
+export * from "./graphql";
+export * from "./rest";
+
+export * from "./types";
+export * from "./errors";
+export * from "./server";

package/src/api/openapi-generator.ts

@@ -0,0 +1,160 @@
+import { EntityCollection, Property } from "@rebasepro/types";
+
+export function generateOpenApiSpec(collections: EntityCollection[], basePath: string = "/api"): Record<string, unknown> {
+    const spec = {
+        openapi: "3.0.0",
+        info: {
+            title: "Rebase Auto-Generated API",
+            version: "1.0.0",
+            description: "Automatically generated REST API from Rebase collections"
+        },
+        servers: [
+            {
+                url: basePath,
+                description: "API Server"
+            }
+        ],
+        paths: {} as Record<string, unknown>,
+        components: {
+            schemas: {} as Record<string, unknown>
+        }
+    };
+
+    (collections || []).forEach(collection => {
+        const schemaName = collection.singularName || collection.name;
+        spec.components.schemas[schemaName] = {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                ...Object.entries(collection.properties).reduce((props, [key, property]) => {
+                    if (property.type !== "relation") {
+                        props[key] = convertPropertyToOpenApiType(property);
+                    }
+                    return props;
+                }, {} as Record<string, unknown>)
+            }
+        };
+
+        const collectionPath = `/${collection.slug}`;
+
+        spec.paths[collectionPath] = {
+            get: {
+                summary: `List ${collection.name}`,
+                parameters: [
+                    { name: "limit", in: "query", schema: { type: "integer", default: 20 } },
+                    { name: "offset", in: "query", schema: { type: "integer", default: 0 } },
+                    { name: "where", in: "query", schema: { type: "string" } },
+                    { name: "orderBy", in: "query", schema: { type: "string" } }
+                ],
+                responses: {
+                    200: {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        data: {
+                                            type: "array",
+                                            items: { $ref: `#/components/schemas/${schemaName}` }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            post: {
+                summary: `Create ${schemaName}`,
+                requestBody: {
+                    content: {
+                        "application/json": {
+                            schema: { $ref: `#/components/schemas/${schemaName}` }
+                        }
+                    }
+                },
+                responses: {
+                    201: {
+                        description: "Created",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${schemaName}` }
+                            }
+                        }
+                    }
+                }
+            }
+        };
+
+        spec.paths[`${collectionPath}/{id}`] = {
+            get: {
+                summary: `Get ${schemaName} by ID`,
+                parameters: [
+                    { name: "id", in: "path", required: true, schema: { type: "string" } }
+                ],
+                responses: {
+                    200: {
+                        description: "Success",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${schemaName}` }
+                            }
+                        }
+                    }
+                }
+            },
+            put: {
+                summary: `Update ${schemaName}`,
+                parameters: [
+                    { name: "id", in: "path", required: true, schema: { type: "string" } }
+                ],
+                requestBody: {
+                    content: {
+                        "application/json": {
+                            schema: { $ref: `#/components/schemas/${schemaName}` }
+                        }
+                    }
+                },
+                responses: {
+                    200: {
+                        description: "Updated",
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${schemaName}` }
+                            }
+                        }
+                    }
+                }
+            },
+            delete: {
+                summary: `Delete ${schemaName}`,
+                parameters: [
+                    { name: "id", in: "path", required: true, schema: { type: "string" } }
+                ],
+                responses: {
+                    204: { description: "Deleted" }
+                }
+            }
+        };
+    });
+
+    return spec;
+}
+
+function convertPropertyToOpenApiType(property: Property): Record<string, unknown> {
+    switch (property.type) {
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "date":
+            return { type: "string", format: "date-time" };
+        case "array":
+            return { type: "array", items: { type: "string" } };
+        default:
+            return { type: "string" };
+    }
+}