@rebasepro/admin 0.11.1-canary.gfd39654 → 0.12.0

package/src/collection_editor/pgColumnToProperty.ts

@@ -1,291 +0,0 @@
-import { Property, StringProperty, NumberProperty, ArrayProperty, TableColumnInfo, TableMetadata, PostgresProperties } from "@rebasepro/types";
-import { prettifyIdentifier } from "@rebasepro/utils";
-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 = prettifyIdentifier(column_name);
-
-    // 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: prettifyIdentifier(v) })),
-            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[] = [];
-    const relations: any[] = []; // In the builder/editor, target can be a string path before hydration
-    const securityRules: any[] = [];
-
-    // Parse columns
-    for (const column of metadata.columns) {
-        const property = pgTypeToRebaseProperty(column);
-        if (property) {
-            // Remove undefined keys so we don't output "validation: undefined"
-            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
-                cardinality: "one",
-                direction: "owning",
-                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
-                cardinality: "many",
-                direction: "owning",
-                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: string[] = [];
-            switch (policy.cmd) {
-                case "ALL": operations = ["read", "create", "update", "delete"]; break;
-                case "SELECT": operations = ["read"]; break;
-                case "INSERT": operations = ["create"]; break;
-                case "UPDATE": operations = ["update"]; break;
-                case "DELETE": operations = ["delete"]; break;
-            }
-            securityRules.push({
-                name: policy.policy_name,
-                operations,
-                // roles is string[] e.g., ["public", "authenticated"]
-                roles: policy.roles ?? [],
-                qual: policy.qual,
-                with_check: policy.with_check
-            });
-        }
-    }
-
-    const prettifiedName = prettifyIdentifier(tableName);
-
-    return {
-        name: prettifiedName,
-        slug: tableName,
-        table: tableName,
-        properties: properties as PostgresProperties,
-        propertiesOrder,
-        ...(relations.length > 0 ? { relations } : {}),
-        ...(securityRules.length > 0 ? { securityRules } : {})
-    };
-}

package/src/editor/extensions/Image/index.ts

@@ -1,133 +0,0 @@
-import { Decoration, DecorationSet, EditorView } from "prosemirror-view";
-import { Plugin, PluginKey } from "prosemirror-state";
-import { schema } from "../../schema";
-
-export type UploadFn = (image: File) => Promise<string>;
-
-export async function onFileRead(view: EditorView, readerEvent: ProgressEvent<FileReader>, pos: number, upload: UploadFn, image: File) {
-    const state = view.state as typeof view.state & { plugins: Plugin[] };
-    const plugin = state.plugins.find((p: Plugin) => p.spec.key === ImagePluginKey);
-    if (!plugin) {
-        console.error("Image plugin not found");
-        return;
-    }
-    let decorationSet = plugin.getState(view.state);
-
-    const placeholder = document.createElement("div");
-    const imageElement = document.createElement("img");
-    // basic styling for loading state
-    imageElement.setAttribute("class", "opacity-40 rounded-lg border");
-    imageElement.src = readerEvent.target?.result as string;
-    placeholder.appendChild(imageElement);
-
-    const deco = Decoration.widget(pos, placeholder);
-    decorationSet = decorationSet?.add(view.state.doc, [deco]);
-    view.dispatch(view.state.tr.setMeta(plugin, { decorationSet }));
-
-    // Image Upload Logic
-    const src = await upload(image);
-    console.debug("Uploaded image", src);
-
-    // Replace placeholder with actual image
-    const imageNode = schema.nodes.image.create({ src });
-    const tr = view.state.tr.replaceWith(pos, pos, imageNode);
-
-    // Remove placeholder decoration
-    decorationSet = decorationSet?.remove([deco]);
-    tr.setMeta(plugin, { decorationSet });
-    view.dispatch(tr);
-}
-
-export const ImagePluginKey = new PluginKey("imagePlugin");
-
-export const createDropImagePlugin = (upload: UploadFn): Plugin => {
-    const plugin: Plugin = new Plugin({
-        key: ImagePluginKey,
-        state: {
-            // Initialize the plugin state with an empty DecorationSet
-            init: () => DecorationSet.empty,
-            // Apply transactions to update the state
-            apply: (tr, old) => {
-                // Handle custom transaction steps that update decorations
-                const meta = tr.getMeta(plugin);
-                if (meta && meta.decorationSet) {
-                    return meta.decorationSet;
-                }
-                // Map decorations to the new document structure
-                return old.map(tr.mapping, tr.doc);
-            }
-        },
-        props: {
-            handleDOMEvents: {
-                drop: (view, event) => {
-                    if (!event.dataTransfer?.files || event.dataTransfer?.files.length === 0) {
-                        return false;
-                    }
-                    event.preventDefault();
-
-                    const files = Array.from(event.dataTransfer.files);
-                    const images = files.filter(file => /image/i.test(file.type));
-
-                    if (images.length === 0) {
-                        console.debug("No images found in dropped files");
-                        return false;
-                    }
-
-                    images.forEach(image => {
-                        const position = view.posAtCoords({
-                            left: event.clientX,
-                            top: event.clientY
-                        });
-                        if (!position) return;
-
-                        const reader = new FileReader();
-                        reader.onload = async (readerEvent) => {
-                            await onFileRead(view, readerEvent, position.pos, upload, image);
-                        };
-                        reader.readAsDataURL(image);
-                    });
-
-                    return true;
-                }
-            },
-            handlePaste(view, event, slice) {
-                const items = Array.from(event.clipboardData?.items || []);
-                const pos = view.state.selection.from;
-                let anyImageFound = false;
-
-                items.forEach((item) => {
-                    const image = item.getAsFile();
-                    if (image && /image/i.test(item.type)) {
-                        anyImageFound = true;
-                        const reader = new FileReader();
-
-                        reader.onload = async (readerEvent) => {
-                            await onFileRead(view, readerEvent, pos, upload, image);
-                        };
-                        reader.readAsDataURL(image);
-                    }
-                });
-
-                return anyImageFound;
-            },
-            decorations(state) {
-                return plugin.getState(state);
-            }
-        },
-        view(editorView) {
-            // This is needed to immediately apply the decoration updates
-            return {
-                update(view, prevState) {
-                    const prevDecos = plugin.getState(prevState);
-                    const newDecos = plugin.getState(view.state);
-
-                    if (prevDecos !== newDecos) {
-                        view.updateState(view.state);
-                    }
-                }
-            };
-        }
-    });
-
-    return plugin;
-};