@rebasepro/server-postgresql 0.0.1-canary.09e5ec5

package/dist/types/src/types/user_management_delegate.d.ts

@@ -0,0 +1,121 @@
+import { Role, User } from "../users";
+/**
+ * Result of creating a new user via admin flow.
+ * Contains the created user plus information about how credentials were delivered.
+ */
+export interface UserCreationResult<USER extends User = User> {
+    /** The created user */
+    user: USER;
+    /** Whether an invitation email was sent to the user */
+    invitationSent: boolean;
+    /**
+     * Temporary password (only present when email service is not configured).
+     * This is returned one-time and should be shown to the admin to share manually.
+     */
+    temporaryPassword?: string;
+}
+/**
+ * Delegate to manage users, roles, and their permissions.
+ * This interface allows the CMS to be completely agnostic of the underlying
+ * authentication provider or backend.
+ *
+ * @group Models
+ */
+export interface UserManagementDelegate<USER extends User = User> {
+    /**
+     * Are the users and roles currently being fetched?
+     */
+    loading: boolean;
+    /**
+     * List of users managed by the CMS.
+     */
+    users: USER[];
+    /**
+     * Optional error if users failed to load.
+     */
+    usersError?: Error;
+    /**
+     * Function to get a user by its uid. This is used to show
+     * user information when assigning ownership of an entity.
+     * @param uid
+     */
+    getUser: (uid: string) => USER | null;
+    /**
+     * Search users with server-side pagination.
+     * When provided, the CMS will use this for the users table
+     * instead of loading all users into memory.
+     */
+    searchUsers?: (options: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+        orderBy?: string;
+        orderDir?: "asc" | "desc";
+        roleId?: string;
+    }) => Promise<{
+        users: USER[];
+        total: number;
+    }>;
+    /**
+     * Save a user (create or update)
+     * @param user
+     */
+    saveUser?: (user: USER) => Promise<USER>;
+    /**
+     * Create a new user with invitation/password generation support.
+     * Returns additional info about how the credentials were delivered.
+     * Falls back to saveUser if not provided.
+     */
+    createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Reset the password for an existing user.
+     * Returns a temporary password if no email service is configured,
+     * or a flag indicating an email invitation was sent.
+     */
+    resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
+    /**
+     * Delete a user
+     * @param user
+     */
+    deleteUser?: (user: USER) => Promise<void>;
+    /**
+     * List of roles defined in the CMS.
+     */
+    roles?: Role[];
+    /**
+     * Optional error if roles failed to load.
+     */
+    rolesError?: Error;
+    /**
+     * Save a role (create or update)
+     * @param role
+     */
+    saveRole?: (role: Role) => Promise<void>;
+    /**
+     * Delete a role
+     * @param role
+     */
+    deleteRole?: (role: Role) => Promise<void>;
+    /**
+     * Is the currently logged in user an admin?
+     */
+    isAdmin?: boolean;
+    /**
+     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
+     */
+    allowDefaultRolesCreation?: boolean;
+    /**
+     * Should collection config permissions be included?
+     */
+    includeCollectionConfigPermissions?: boolean;
+    /**
+     * Optionally define roles for a given user. This is useful when the roles
+     * are coming from a separate provider than the one issuing the tokens.
+     */
+    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    /**
+     * Optional function to bootstrap an admin user.
+     * Often used when the database is empty.
+     */
+    bootstrapAdmin?: () => Promise<void>;
+}

package/dist/types/src/types/websockets.d.ts

@@ -0,0 +1,78 @@
+import { Entity } from "./entities";
+export interface WebSocketErrorPayload {
+    error?: string | {
+        message: string;
+        code?: string;
+    };
+    message?: string;
+    code?: string;
+}
+export interface WebSocketMessage {
+    type: string;
+    payload?: unknown;
+    subscriptionId?: string;
+    requestId?: string;
+    entities?: Entity<Record<string, unknown>>[];
+    entity?: Entity<Record<string, unknown>> | null;
+    error?: string;
+}
+export interface CollectionUpdateMessage extends WebSocketMessage {
+    type: "collection_update";
+    subscriptionId: string;
+    entities: Entity<Record<string, unknown>>[];
+}
+export interface EntityUpdateMessage extends WebSocketMessage {
+    type: "entity_update";
+    subscriptionId: string;
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Lightweight patch message sent to collection subscribers when a single
+ * entity is created, updated, or deleted. The client can merge this into
+ * its cached collection data for near-instant cross-tab updates without
+ * waiting for a full collection refetch.
+ */
+export interface CollectionEntityPatchMessage extends WebSocketMessage {
+    type: "collection_entity_patch";
+    subscriptionId: string;
+    entityId: string;
+    /** The updated entity, or null if deleted */
+    entity: Entity<Record<string, unknown>> | null;
+}
+/**
+ * Column metadata returned by table introspection.
+ */
+export interface TableColumnInfo {
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    is_nullable: string;
+    column_default: string | null;
+    character_maximum_length: number | null;
+    /** Enum values, populated for USER-DEFINED (enum) columns */
+    enum_values?: string[];
+}
+export interface TableForeignKeyInfo {
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+export interface TableJunctionInfo {
+    junction_table_name: string;
+    source_column_name: string;
+    target_table_name: string;
+    target_column_name: string;
+}
+export interface TablePolicyInfo {
+    policy_name: string;
+    roles: string[];
+    cmd: string;
+    qual?: string;
+    with_check?: string;
+}
+export interface TableMetadata {
+    columns: TableColumnInfo[];
+    foreignKeys: TableForeignKeyInfo[];
+    junctions: TableJunctionInfo[];
+    policies: TablePolicyInfo[];
+}

package/dist/types/src/users/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./user";
+export * from "./roles";

package/dist/types/src/users/roles.d.ts

@@ -0,0 +1,22 @@
+export type Role = {
+    /**
+     * ID of the role
+     */
+    id: string;
+    /**
+     * Name of the role
+     */
+    name: string;
+    /**
+     * If this flag is true, the user can perform any action
+     */
+    isAdmin?: boolean;
+    /**
+     * Permissions related to editing the collections
+     */
+    config?: {
+        createCollections?: boolean;
+        editCollections?: boolean | "own";
+        deleteCollections?: boolean | "own";
+    };
+};

package/dist/types/src/users/user.d.ts

@@ -0,0 +1,46 @@
+/**
+ * This interface represents a user.
+ * It has some of the same fields as a Firebase User.
+ * Note that in the default implementation, we simply take the Firebase user
+ * and use it as a Rebase user, so that means that even if they are not mapped
+ * in this interface, it contains all the methods of the former, such as `delete`,
+ * `getIdToken`, etc.
+ *
+ * @group Models
+ */
+export type User = {
+    /**
+     * The user's unique ID, scoped to the project.
+     */
+    readonly uid: string;
+    /**
+     * The display name of the user.
+     */
+    readonly displayName: string | null;
+    /**
+     * The email of the user.
+     */
+    readonly email: string | null;
+    /**
+     * The profile photo URL of the user.
+     */
+    readonly photoURL: string | null;
+    /**
+     * The provider used to authenticate the user.
+     */
+    readonly providerId: string;
+    /**
+     *
+     */
+    readonly isAnonymous: boolean;
+    /**
+     * Role IDs assigned to this user (e.g. ["admin", "editor"]).
+     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
+     */
+    roles?: string[];
+    /**
+     * The date and time when the user was created.
+     */
+    createdAt?: Date | string | null;
+    getIdToken?: (forceRefresh?: boolean) => Promise<string>;
+};

package/drizzle-test/0000_woozy_junta.sql

@@ -0,0 +1,6 @@
+CREATE TABLE "test" (
+	"id" text PRIMARY KEY NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "test" ENABLE ROW LEVEL SECURITY;--> statement-breakpoint
+CREATE POLICY "old_policy" ON "test" AS PERMISSIVE FOR SELECT TO public;

package/drizzle-test/0001_youthful_arachne.sql

@@ -0,0 +1 @@
+ALTER POLICY "old_policy" ON "test" TO public USING (true);

package/drizzle-test/0002_lively_dragon_lord.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "test" DISABLE ROW LEVEL SECURITY;--> statement-breakpoint
+DROP POLICY "old_policy" ON "test" CASCADE;

package/drizzle-test/0003_mean_king_cobra.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "test" ENABLE ROW LEVEL SECURITY;--> statement-breakpoint
+CREATE POLICY "new_policy" ON "test" AS PERMISSIVE FOR SELECT TO public USING (true);

package/drizzle-test/meta/0000_snapshot.json

@@ -0,0 +1,47 @@
+{
+  "id": "929ed59c-6874-4679-8649-8d3f7dd62890",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.test": {
+      "name": "test",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {
+        "old_policy": {
+          "name": "old_policy",
+          "as": "PERMISSIVE",
+          "for": "SELECT",
+          "to": [
+            "public"
+          ]
+        }
+      },
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test/meta/0001_snapshot.json

@@ -0,0 +1,48 @@
+{
+  "id": "8c2b226d-6aa5-4c33-b94b-7ba184d457ba",
+  "prevId": "929ed59c-6874-4679-8649-8d3f7dd62890",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.test": {
+      "name": "test",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {
+        "old_policy": {
+          "name": "old_policy",
+          "as": "PERMISSIVE",
+          "for": "SELECT",
+          "to": [
+            "public"
+          ],
+          "using": "true"
+        }
+      },
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test/meta/0002_snapshot.json

@@ -0,0 +1,38 @@
+{
+  "id": "d30b4ec3-fde2-43ff-ad78-48fa68b0574a",
+  "prevId": "8c2b226d-6aa5-4c33-b94b-7ba184d457ba",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.test": {
+      "name": "test",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test/meta/0003_snapshot.json

@@ -0,0 +1,48 @@
+{
+  "id": "ed312842-4f9b-48a9-af26-036c1f5d7eee",
+  "prevId": "d30b4ec3-fde2-43ff-ad78-48fa68b0574a",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.test": {
+      "name": "test",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {
+        "new_policy": {
+          "name": "new_policy",
+          "as": "PERMISSIVE",
+          "for": "SELECT",
+          "to": [
+            "public"
+          ],
+          "using": "true"
+        }
+      },
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test/meta/_journal.json

@@ -0,0 +1,34 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1777412472270,
+      "tag": "0000_woozy_junta",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1777412577921,
+      "tag": "0001_youthful_arachne",
+      "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "7",
+      "when": 1777412591133,
+      "tag": "0002_lively_dragon_lord",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "7",
+      "when": 1777412614502,
+      "tag": "0003_mean_king_cobra",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle-test-out/0000_tan_trauma.sql

@@ -0,0 +1,6 @@
+CREATE TABLE "users" (
+	"id" integer PRIMARY KEY NOT NULL,
+	"name" varchar
+);
+--> statement-breakpoint
+ALTER TABLE "users" ENABLE ROW LEVEL SECURITY;

package/drizzle-test-out/0001_rapid_drax.sql

@@ -0,0 +1 @@
+CREATE POLICY "test_policy" ON "users" AS PERMISSIVE FOR ALL TO public USING (true);

package/drizzle-test-out/meta/0000_snapshot.json

@@ -0,0 +1,44 @@
+{
+  "id": "ef1380c9-de61-4080-98b0-f790a94d4384",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": true
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test-out/meta/0001_snapshot.json

@@ -0,0 +1,54 @@
+{
+  "id": "d98375cd-115c-4ec6-ae56-cbcc39ea8b13",
+  "prevId": "ef1380c9-de61-4080-98b0-f790a94d4384",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {
+        "test_policy": {
+          "name": "test_policy",
+          "as": "PERMISSIVE",
+          "for": "ALL",
+          "to": [
+            "public"
+          ],
+          "using": "true"
+        }
+      },
+      "checkConstraints": {},
+      "isRLSEnabled": true
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/drizzle-test-out/meta/_journal.json

@@ -0,0 +1,20 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1777413439093,
+      "tag": "0000_tan_trauma",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1777413457223,
+      "tag": "0001_rapid_drax",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.test.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+    schema: "./test-schema-no-policies.ts",
+    out: "./drizzle-test-out",
+    dialect: "postgresql",
+    dbCredentials: {
+        url: process.env.DATABASE_URL || "postgres://postgres:postgres@localhost:5432/postgres"
+    }
+});