@rebasepro/studio 0.11.1-canary.gfd39654 → 0.12.0

package/src/utils/pgColumnToProperty.ts

@@ -1,310 +0,0 @@
-import type { PostgresProperties, Property, StringProperty, NumberProperty, ArrayProperty, TableColumnInfo, TableMetadata, SecurityOperation, SecurityRule } from "@rebasepro/types";
-import type { AdminCollection } from "@rebasepro/admin-types";
-
-/**
- * Maps a PostgreSQL column data type to a Rebase property type.
- */
-function pgTypeToRebaseProperty(column: TableColumnInfo): Property | null {
-    const {
-        column_name,
-        data_type,
-        udt_name,
-        is_nullable,
-        column_default,
-        enum_values
-    } = column;
-
-    const required = is_nullable === "NO";
-    const prettifiedName = column_name
-        .replace(/_/g, " ")
-        .replace(/\b\w/g, (c: string) => c.toUpperCase());
-
-    // Detect if this column is a primary key (auto-generated id)
-    const isAutoId = column_default != null && (
-        column_default.includes("nextval") ||
-        column_default.includes("gen_random_uuid") ||
-        column_default.includes("uuid_generate") ||
-        column_default.includes("identity")
-    );
-
-    // USER-DEFINED = PostgreSQL enums
-    if (data_type === "USER-DEFINED" && enum_values && enum_values.length > 0) {
-        return {
-            type: "string",
-            name: prettifiedName,
-            enum: enum_values.map((v: string) => ({ id: v,
-label: v.replace(/_/g, " ").replace(/\b\w/g, (c: string) => c.toUpperCase()) })),
-            validation: required ? { required: true } : undefined
-        } as StringProperty;
-    }
-
-    const dt = data_type.toLowerCase();
-    switch (dt) {
-        case "character varying":
-        case "varchar":
-        case "text":
-        case "char":
-        case "character":
-        case "citext": {
-            let colType: "varchar" | "text" | "char" = "varchar";
-            if (dt === "text" || dt === "citext") colType = "text";
-            if (dt === "char" || dt === "character") colType = "char";
-            const prop: StringProperty = {
-                type: "string",
-                name: prettifiedName,
-                columnType: colType,
-                validation: required ? { required: true } : undefined
-            };
-            if (isAutoId) {
-                prop.isId = "manual";
-            }
-            return prop;
-        }
-
-        case "uuid": {
-            const prop: StringProperty = {
-                type: "string",
-                name: prettifiedName,
-                validation: required ? { required: true } : undefined
-            };
-            if (isAutoId) {
-                prop.isId = "uuid";
-            }
-            return prop;
-        }
-
-        case "integer":
-        case "bigint":
-        case "smallint": {
-            const colType = dt === "bigint" ? "bigint" : "integer";
-            const prop: NumberProperty = {
-                type: "number",
-                name: prettifiedName,
-                columnType: colType,
-                validation: {
-                    ...(required ? { required: true } : {}),
-                    integer: true
-                }
-            };
-            if (isAutoId) {
-                prop.isId = "increment";
-            }
-            return prop;
-        }
-
-        case "serial":
-        case "bigserial":
-        case "smallserial": {
-            const colType = dt === "bigserial" ? "bigserial" : "serial";
-            return {
-                type: "number",
-                name: prettifiedName,
-                columnType: colType,
-                isId: "increment",
-                validation: {
-                    ...(required ? { required: true } : {}),
-                    integer: true
-                }
-            } as NumberProperty;
-        }
-
-        case "numeric":
-        case "decimal":
-        case "real":
-        case "double precision": {
-            let colType: "numeric" | "real" | "double precision" = "numeric";
-            if (dt === "real") colType = "real";
-            if (dt === "double precision") colType = "double precision";
-            return {
-                type: "number",
-                name: prettifiedName,
-                columnType: colType,
-                validation: required ? { required: true } : undefined
-            };
-        }
-
-        case "boolean":
-            return {
-                type: "boolean",
-                name: prettifiedName,
-                validation: required ? { required: true } : undefined
-            };
-
-        case "timestamp with time zone":
-        case "timestamp without time zone":
-        case "timestamp":
-        case "timestamptz":
-        case "date":
-        case "time with time zone":
-        case "time without time zone":
-        case "time": {
-            let colType: "timestamp" | "date" | "time" = "timestamp";
-            if (dt.startsWith("date")) colType = "date";
-            if (dt.startsWith("time ") || dt === "time") colType = "time";
-            return {
-                type: "date",
-                name: prettifiedName,
-                columnType: colType,
-                validation: required ? { required: true } : undefined
-            };
-        }
-
-        case "jsonb":
-        case "json":
-            return {
-                type: "map",
-                name: prettifiedName,
-                columnType: dt === "jsonb" ? "jsonb" : "json",
-                keyValue: true,
-                properties: {}
-            };
-
-        case "array":
-        case "ARRAY": {
-            let innerType = "string";
-            let colType: ArrayProperty["columnType"] = undefined;
-            if (udt_name === "_text" || udt_name === "_varchar") {
-                innerType = "string";
-                colType = "text[]";
-            } else if (udt_name === "_int4" || udt_name === "_int2" || udt_name === "_int8") {
-                innerType = "number";
-                colType = "integer[]";
-            } else if (udt_name === "_bool") {
-                innerType = "boolean";
-                colType = "boolean[]";
-            } else if (udt_name === "_numeric") {
-                innerType = "number";
-                colType = "numeric[]";
-            }
-            return {
-                type: "array",
-                name: prettifiedName,
-                columnType: colType,
-                of: { type: innerType }
-            } as ArrayProperty;
-        }
-
-        default:
-            // Fallback: treat unknown types as string
-            return {
-                type: "string",
-                name: prettifiedName,
-                validation: required ? { required: true } : undefined
-            };
-    }
-}
-
-/**
- * Builds a partial AdminCollection from PostgreSQL table metadata.
- * This is used when creating a new collection from an existing database table.
- */
-export function buildCollectionFromTableMetadata(
-    tableName: string,
-    metadata: TableMetadata
-): Partial<AdminCollection> {
-    const properties: Record<string, Property> = {};
-    const propertiesOrder: string[] = [];
-    // Introspection can only ever produce two shapes: a foreign key on this
-    // table, or a junction between two. Both are named by their kind.
-    const relations: Array<{
-        id: string;
-        relationName: string;
-        target: string;
-        kind: "belongsTo" | "manyToMany";
-        localKey?: string;
-        through?: { table: string; sourceColumn: string; targetColumn: string };
-    }> = [];
-    const securityRules: SecurityRule[] = [];
-
-    // Parse columns
-    for (const column of metadata.columns) {
-        const property = pgTypeToRebaseProperty(column);
-        if (property) {
-            const propRecord = property as unknown as Record<string, unknown>;
-            Object.keys(propRecord).forEach(key => propRecord[key] === undefined && delete propRecord[key]);
-
-            properties[column.column_name] = property;
-            propertiesOrder.push(column.column_name);
-        }
-    }
-
-    // Parse Outgoing Foreign Keys -> Many-to-One / One-to-One
-    if (metadata.foreignKeys) {
-        for (const fk of metadata.foreignKeys) {
-            const relName = fk.column_name.endsWith("_id") ? fk.column_name.substring(0, fk.column_name.length - 3) : fk.column_name;
-            relations.push({
-                id: fk.column_name,
-                relationName: relName,
-                target: fk.foreign_table_name, // Will be hydrated later
-                kind: "belongsTo",
-                localKey: fk.column_name
-            });
-        }
-    }
-
-    // Parse Incoming Junctions -> Many-to-Many
-    if (metadata.junctions) {
-        for (const junction of metadata.junctions) {
-            const relName = junction.target_table_name; // E.g., 'roles'
-            relations.push({
-                id: junction.target_table_name + "_relation",
-                relationName: relName,
-                target: junction.target_table_name, // Will be hydrated later
-                kind: "manyToMany",
-                through: {
-                    table: junction.junction_table_name,
-                    sourceColumn: junction.source_column_name,
-                    targetColumn: junction.target_column_name
-                }
-            });
-        }
-    }
-
-    // Parse RLS Policies
-    if (metadata.policies) {
-        for (const policy of metadata.policies) {
-            // Attempt to map typical cmds to operations.
-            // Postgres cmd: SELECT, INSERT, UPDATE, DELETE, ALL
-            let operations: SecurityOperation[] = [];
-            switch (policy.cmd) {
-                case "ALL": operations = ["all"]; break;
-                case "SELECT": operations = ["select"]; break;
-                case "INSERT": operations = ["insert"]; break;
-                case "UPDATE": operations = ["update"]; break;
-                case "DELETE": operations = ["delete"]; break;
-            }
-            const qual = policy.qual ?? undefined;
-            const withCheck = policy.with_check ?? undefined;
-            if (qual) {
-                securityRules.push({
-                    name: policy.policy_name,
-                    operations,
-                    roles: policy.roles ?? [],
-                    using: qual,
-                    ...(withCheck ? { withCheck } : {})
-                });
-            } else {
-                securityRules.push({
-                    name: policy.policy_name,
-                    operations,
-                    roles: policy.roles ?? []
-                });
-            }
-        }
-    }
-
-    const prettifiedName = tableName
-        .replace(/_/g, " ")
-        .replace(/\b\w/g, (c: string) => c.toUpperCase());
-
-    return {
-        name: prettifiedName,
-        slug: tableName,
-        table: tableName,
-        properties: properties as PostgresProperties,
-        propertiesOrder,
-        // `target` is still a slug here — the caller hydrates it into a thunk.
-        ...(relations.length > 0 ? { relations: relations as unknown as AdminCollection["relations"] } : {}),
-        ...(securityRules.length > 0 ? { securityRules } : {})
-    };
-}