@rebasepro/server-postgresql 0.1.0 → 0.2.1

package/src/cli.ts

@@ -1,6 +1,6 @@
 import arg from "arg";
 import chalk from "chalk";
-import execa from "execa";
+import { execa } from "execa";
 import path from "path";
 import fs from "fs";
 import { execSync } from "child_process";
@@ -11,14 +11,17 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function resolveLocalBin(binName: string): string | null {
     let cwd = process.cwd();
     // Try to find node_modules/.bin upwards
-    while (cwd !== "/") {
+    while (true) {
         const candidate = path.join(cwd, "node_modules", ".bin", binName);
         if (fs.existsSync(candidate)) return candidate;
-        cwd = path.dirname(cwd);
+        const parent = path.dirname(cwd);
+        if (parent === cwd) break;
+        cwd = parent;
     }
-    // Fall back to globally installed binary via which
+    // Fall back to globally installed binary via which/where
     try {
-        const globalPath = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
+        const cmd = process.platform === "win32" ? `where ${binName}` : `which ${binName}`;
+        const globalPath = execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0].trim();
         if (globalPath && fs.existsSync(globalPath)) return globalPath;
     } catch {
         // not found globally
@@ -89,6 +92,13 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
             await runDrizzleKit("push", rawArgs);
         } else if (subcommand === "migrate") {
             await runDrizzleKit("migrate", rawArgs);
+        } else if (subcommand === "studio") {
+            const schemaPath = path.join(process.cwd(), "src", "schema.generated.ts");
+            if (!fs.existsSync(schemaPath)) {
+                console.log(chalk.yellow("  ⚠ schema.generated.ts not found. Generating schema first..."));
+                await schemaCommand("generate", rawArgs);
+            }
+            await runDrizzleKit("studio", rawArgs);
         } else {
             await runDrizzleKit(subcommand, rawArgs);
         }
@@ -312,7 +322,12 @@ async function fixMigrationStatementOrder(): Promise<void> {
     if (sqlFiles.length === 0) return;
 
     const latestFile = path.join(drizzleDir, sqlFiles[0].name);
-    const content = fs.readFileSync(latestFile, "utf-8");
+    let content = fs.readFileSync(latestFile, "utf-8");
+    const originalContent = content;
+
+    // Replace CREATE SCHEMA with CREATE SCHEMA IF NOT EXISTS to prevent failures
+    content = content.replace(/CREATE SCHEMA "([^"]+)";/g, 'CREATE SCHEMA IF NOT EXISTS "$1";');
+
     const DELIMITER = "--> statement-breakpoint";
     const parts = content.split(DELIMITER);
 
@@ -354,7 +369,12 @@ async function fixMigrationStatementOrder(): Promise<void> {
         if (needsReorder) break;
     }
 
-    if (!needsReorder) return;
+    if (!needsReorder) {
+        if (content !== originalContent) {
+            fs.writeFileSync(latestFile, content, "utf-8");
+        }
+        return;
+    }
 
     // Reorder: move DROP POLICY statements for affected tables before their ALTER TABLE
     // Strategy: stable sort — DROP POLICY on table X gets priority over ALTER on table X
@@ -378,7 +398,7 @@ idx }));
     const reordered = stmtEntries.map(e => e.stmt).join(DELIMITER);
     fs.writeFileSync(latestFile, reordered, "utf-8");
 
-    console.log(chalk.yellow(`  ⚠ Reordered migration statements in ${sqlFiles[0].name} (DROP POLICY before ALTER COLUMN)`));
+    console.log(chalk.yellow(`  \u26A0 Reordered migration statements in ${sqlFiles[0].name} (DROP POLICY before ALTER COLUMN)`));
 }
 
 async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void> {
@@ -403,7 +423,11 @@ async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void>
             if (fs.existsSync(p)) {
                 const parsed = dotenv.config({ path: p });
                 if (parsed.parsed) {
-                    Object.assign(env, parsed.parsed);
+                    for (const [key, val] of Object.entries(parsed.parsed)) {
+                        if (env[key] === undefined) {
+                            env[key] = val;
+                        }
+                    }
                     break;
                 }
             }
@@ -419,6 +443,9 @@ async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void>
     const drizzleKitArgs = [action];
     if (action === "push") {
         drizzleKitArgs.push("--strict", "--verbose");
+        if (_rawArgs.includes("--force")) {
+            drizzleKitArgs.push("--force");
+        }
     }
 
     try {
@@ -512,7 +539,7 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
             process.exit(1);
         }
 
-        const collectionsPath = argsList["--collections"] || path.join("..", "shared", "collections");
+        const collectionsPath = argsList["--collections"] || path.join("..", "config", "collections");
         const outputPath = argsList["--output"] || path.join("src", "schema.generated.ts");
         const watch = argsList["--watch"] || false;
 
@@ -604,8 +631,10 @@ async function doctorPluginCommand(rawArgs: string[]): Promise<void> {
         {
             "--collections": String,
             "--schema": String,
+            "--sdk": String,
             "-c": "--collections",
-            "-s": "--schema"
+            "-s": "--schema",
+            "-k": "--sdk"
         },
         {
             argv: rawArgs.slice(1), // skip "doctor"
@@ -625,14 +654,16 @@ async function doctorPluginCommand(rawArgs: string[]): Promise<void> {
         process.exit(1);
     }
 
-    const collectionsPath = parsedArgs["--collections"] || path.join("..", "shared", "collections");
+    const collectionsPath = parsedArgs["--collections"] || path.join("..", "config", "collections");
     const schemaPath = parsedArgs["--schema"] || path.join("src", "schema.generated.ts");
+    const sdkPath = parsedArgs["--sdk"] || path.join("..", "generated", "sdk", "database.types.ts");
 
     const cmdParts = [
         tsxBin,
         doctorScript,
         `--collections=${collectionsPath}`,
-        `--schema=${schemaPath}`
+        `--schema=${schemaPath}`,
+        `--sdk=${sdkPath}`
     ];
 
     try {

package/src/data-transformer.ts

@@ -1,7 +1,7 @@
 import { eq, SQL } from "drizzle-orm";
 import { AnyPgColumn } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { CollectionWithRelations, EntityCollection, Properties, Property, Relation, RelationProperty } from "@rebasepro/types";
+import { CollectionWithRelations, EntityCollection, Properties, Property, Relation, RelationProperty, Vector, BinaryProperty } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations, findRelation, createRelationRef, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
@@ -127,6 +127,8 @@ export function serializeDataToServer<M extends Record<string, unknown>>(
             continue;
         }
 
+
+
         // Handle relation properties specially
         if (property.type === "relation" && collection) {
             const relation = findRelation(resolvedRelations, key);
@@ -257,6 +259,32 @@ export function serializePropertyToServer(value: unknown, property: Property): u
                 return result;
             }
             return value;
+        case "vector": {
+            if (value instanceof Vector) {
+                return value.value;
+            }
+            if (value && typeof value === "object" && "value" in value && Array.isArray((value as any).value)) {
+                return (value as any).value.map(Number);
+            }
+            if (Array.isArray(value)) {
+                return value.map(Number);
+            }
+            return value;
+        }
+
+        case "binary":
+            if (typeof value === "string") {
+                if (value.startsWith("data:application/octet-stream;base64,")) {
+                    const base64Data = value.split(",")[1];
+                    if (base64Data) {
+                        return Buffer.from(base64Data, "base64");
+                    }
+                }
+            }
+            if (Buffer.isBuffer(value)) {
+                return value;
+            }
+            return value;
 
         case "string":
             if (typeof value === "string") {
@@ -405,7 +433,7 @@ export async function parseDataFromServer<M extends Record<string, unknown>>(
                             // Add where condition for the current entity
                             if (pks.length === 1) {
                                 const sourceIdField = sourceTable[pks[0].fieldName as keyof typeof sourceTable] as AnyPgColumn;
-                                query = query.where(eq(sourceIdField, currentEntityId)) as unknown as typeof query;
+                                query = query.where(eq(sourceIdField, currentEntityId)) as typeof query;
                             } else {
                                 // For composite keys, we would need to map the split parts. For now log a warning.
                                 console.warn(`Join path resolution for composite primary keys is not yet fully supported: ${collection.slug}`);
@@ -466,6 +494,22 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
     }
 
     switch (property.type) {
+        case "binary": {
+            let buf: Buffer | null = null;
+            if (Buffer.isBuffer(value)) {
+                buf = value;
+            } else if (typeof value === "object" && value !== null) {
+                const rawVal = value as Record<string, unknown>;
+                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
+                    buf = Buffer.from(rawVal.data as number[]);
+                }
+            }
+            if (buf) {
+                return `data:application/octet-stream;base64,${buf.toString("base64")}`;
+            }
+            return value;
+        }
+
         case "string": {
             if (typeof value === "string") return value;
             
@@ -476,9 +520,12 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             if (Buffer.isBuffer(value)) {
                 isBuffer = true;
                 buf = value;
-            } else if (typeof value === "object" && value !== null && (value as any).type === "Buffer" && Array.isArray((value as any).data)) {
-                isBuffer = true;
-                buf = Buffer.from((value as any).data);
+            } else if (typeof value === "object" && value !== null) {
+                const rawVal = value as Record<string, unknown>;
+                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
+                    isBuffer = true;
+                    buf = Buffer.from(rawVal.data as number[]);
+                }
             }
             
             if (isBuffer && buf) {
@@ -577,6 +624,26 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             }
             return value;
 
+        case "vector": {
+            let nums: number[] = [];
+            if (typeof value === "string") {
+                nums = value.slice(1, -1).split(",").map(Number);
+            } else if (Array.isArray(value)) {
+                nums = value.map(Number);
+            } else if (value instanceof Vector) {
+                nums = value.value;
+            } else if (typeof value === "object" && value !== null && "value" in value) {
+                const valObj = value as { value: unknown };
+                if (Array.isArray(valObj.value)) {
+                    nums = valObj.value.map(Number);
+                }
+            }
+            return {
+                __type: "Vector",
+                value: nums
+            };
+        }
+
         case "date": {
             let date: Date | undefined;
             if (value instanceof Date) {
@@ -604,9 +671,12 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
             if (Buffer.isBuffer(value)) {
                 isBuffer = true;
                 buf = value;
-            } else if (typeof value === "object" && value !== null && (value as any).type === "Buffer" && Array.isArray((value as any).data)) {
-                isBuffer = true;
-                buf = Buffer.from((value as any).data);
+            } else if (typeof value === "object" && value !== null) {
+                const rawVal = value as Record<string, unknown>;
+                if (rawVal.type === "Buffer" && Array.isArray(rawVal.data)) {
+                    isBuffer = true;
+                    buf = Buffer.from(rawVal.data as number[]);
+                }
             }
             
             if (isBuffer && buf) {

package/src/history/HistoryService.ts

@@ -209,6 +209,29 @@ export class HistoryService {
 }
 
 
+/**
+ * Deep equality without JSON.stringify.
+ * Handles primitives, arrays, Dates, and plain objects recursively.
+ */
+function deepEqual(a: unknown, b: unknown): boolean {
+    if (a === b) return true;
+    if (a == null || b == null) return false;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return false;
+        return a.every((v, i) => deepEqual(v, b[i]));
+    }
+    if (typeof a === "object" && typeof b === "object") {
+        const aObj = a as Record<string, unknown>;
+        const bObj = b as Record<string, unknown>;
+        const aKeys = Object.keys(aObj);
+        const bKeys = Object.keys(bObj);
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every(k => deepEqual(aObj[k], bObj[k]));
+    }
+    return false;
+}
+
 /**
  * Shallow comparison to find top-level keys that changed between two objects.
  */
@@ -230,12 +253,12 @@ export function findChangedFields(
         if (key.startsWith("__")) continue;
 
         if (oldVal !== newVal) {
-            // For objects/arrays, use JSON comparison
+            // For objects/arrays, use structural comparison
             if (
                 typeof oldVal === "object" && oldVal !== null &&
                 typeof newVal === "object" && newVal !== null
             ) {
-                if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+                if (!deepEqual(oldVal, newVal)) {
                     changed.push(key);
                 }
             } else {

package/src/index.ts

@@ -11,3 +11,4 @@ export * from "./websocket";
 export * from "./collections/PostgresCollectionRegistry";
 export * from "./services/BranchService";
 export * from "./PostgresBootstrapper";
+export * from "./PostgresAdapter";

package/src/schema/auth-schema.ts

@@ -1,116 +1,148 @@
-import { pgSchema, varchar, uuid, timestamp, boolean, jsonb, primaryKey, unique } from "drizzle-orm/pg-core";
+import { pgSchema, pgTable, varchar, uuid, timestamp, boolean, jsonb, primaryKey, unique } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
 
 /**
- * Dedicated PostgreSQL schema for all Rebase internal tables.
- * Keeps the user's `public` schema clean.
+ * Factory function to dynamically create the auth tables bound to the specified schema names.
  */
-export const rebaseSchema = pgSchema("rebase");
+export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchemaName: string = "rebase") {
+    const rolesSchema = rolesSchemaName === "public" ? null : pgSchema(rolesSchemaName);
+    const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
-/**
- * Users table - stores both email/password and OAuth users
- */
-export const users = rebaseSchema.table("users", {
-    id: uuid("id").defaultRandom().primaryKey(),
-    email: varchar("email", { length: 255 }).notNull().unique(),
-    passwordHash: varchar("password_hash", { length: 255 }), // NULL for OAuth-only users
-    displayName: varchar("display_name", { length: 255 }),
-    photoUrl: varchar("photo_url", { length: 500 }),
-    emailVerified: boolean("email_verified").default(false).notNull(),
-    emailVerificationToken: varchar("email_verification_token", { length: 255 }),
-    emailVerificationSentAt: timestamp("email_verification_sent_at"),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-});
+    const rolesTableCreator: any = rolesSchema ? rolesSchema.table.bind(rolesSchema) : pgTable;
+    const usersTableCreator: any = usersSchema ? usersSchema.table.bind(usersSchema) : pgTable;
 
-/**
- * Roles table - defines permission sets
- */
-export const roles = rebaseSchema.table("roles", {
-    id: varchar("id", { length: 50 }).primaryKey(), // 'admin', 'editor', 'viewer'
-    name: varchar("name", { length: 100 }).notNull(),
-    isAdmin: boolean("is_admin").default(false).notNull(),
-    defaultPermissions: jsonb("default_permissions").$type<{
-        read?: boolean;
-        create?: boolean;
-        edit?: boolean;
-        delete?: boolean;
-    }>(),
-    collectionPermissions: jsonb("collection_permissions").$type<
-        Record<string, {
+    /**
+     * Users table - stores both email/password and OAuth users
+     */
+    const users = usersTableCreator("users", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        email: varchar("email", { length: 255 }).notNull().unique(),
+        passwordHash: varchar("password_hash", { length: 255 }), // NULL for OAuth-only users
+        displayName: varchar("display_name", { length: 255 }),
+        photoUrl: varchar("photo_url", { length: 500 }),
+        emailVerified: boolean("email_verified").default(false).notNull(),
+        emailVerificationToken: varchar("email_verification_token", { length: 255 }),
+        emailVerificationSentAt: timestamp("email_verification_sent_at"),
+        metadata: jsonb("metadata").$type<Record<string, any>>().default({}).notNull(),
+        createdAt: timestamp("created_at").defaultNow().notNull(),
+        updatedAt: timestamp("updated_at").defaultNow().notNull()
+    });
+
+    /**
+     * Roles table - defines permission sets
+     */
+    const roles = rolesTableCreator("roles", {
+        id: varchar("id", { length: 50 }).primaryKey(), // 'admin', 'editor', 'viewer'
+        name: varchar("name", { length: 100 }).notNull(),
+        isAdmin: boolean("is_admin").default(false).notNull(),
+        defaultPermissions: jsonb("default_permissions").$type<{
             read?: boolean;
             create?: boolean;
             edit?: boolean;
             delete?: boolean;
-        }>
-    >(),
-    config: jsonb("config").$type<{
-        createCollections?: boolean;
-        editCollections?: "own" | "all" | boolean;
-        deleteCollections?: "own" | "all" | boolean;
-    }>()
-});
+        }>(),
+        collectionPermissions: jsonb("collection_permissions").$type<
+            Record<string, {
+                read?: boolean;
+                create?: boolean;
+                edit?: boolean;
+                delete?: boolean;
+            }>
+        >(),
+        config: jsonb("config").$type<{
+            createCollections?: boolean;
+            editCollections?: "own" | "all" | boolean;
+            deleteCollections?: "own" | "all" | boolean;
+        }>()
+    });
 
-/**
- * User-Role junction table
- */
-export const userRoles = rebaseSchema.table("user_roles", {
-    userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    roleId: varchar("role_id", { length: 50 }).notNull().references(() => roles.id, { onDelete: "cascade" })
-}, (table) => ({
-    pk: primaryKey({ columns: [table.userId, table.roleId] })
-}));
+    /**
+     * User-Role junction table
+     */
+    const userRoles = rolesTableCreator("user_roles", {
+        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+        roleId: varchar("role_id", { length: 50 }).notNull().references(() => roles.id, { onDelete: "cascade" })
+    }, (table: any) => ({
+        pk: primaryKey({ columns: [table.userId, table.roleId] })
+    }));
 
-/**
- * Refresh tokens for long-lived sessions
- */
-export const refreshTokens = rebaseSchema.table("refresh_tokens", {
-    id: uuid("id").defaultRandom().primaryKey(),
-    userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
-    expiresAt: timestamp("expires_at").notNull(),
-    userAgent: varchar("user_agent", { length: 500 }),
-    ipAddress: varchar("ip_address", { length: 45 }),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-}, (table) => ({
-    uniqueDeviceSession: unique("unique_device_session").on(table.userId, table.userAgent, table.ipAddress)
-}));
+    /**
+     * Refresh tokens for long-lived sessions
+     */
+    const refreshTokens = rolesTableCreator("refresh_tokens", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+        tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
+        expiresAt: timestamp("expires_at").notNull(),
+        userAgent: varchar("user_agent", { length: 500 }),
+        ipAddress: varchar("ip_address", { length: 45 }),
+        createdAt: timestamp("created_at").defaultNow().notNull()
+    }, (table: any) => ({
+        uniqueDeviceSession: unique("unique_device_session").on(table.userId, table.userAgent, table.ipAddress)
+    }));
 
-/**
- * Password reset tokens for forgot password flow
- */
-export const passwordResetTokens = rebaseSchema.table("password_reset_tokens", {
-    id: uuid("id").defaultRandom().primaryKey(),
-    userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
-    expiresAt: timestamp("expires_at").notNull(),
-    usedAt: timestamp("used_at"),
-    createdAt: timestamp("created_at").defaultNow().notNull()
-});
+    /**
+     * Password reset tokens for forgot password flow
+     */
+    const passwordResetTokens = rolesTableCreator("password_reset_tokens", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+        tokenHash: varchar("token_hash", { length: 255 }).notNull().unique(),
+        expiresAt: timestamp("expires_at").notNull(),
+        usedAt: timestamp("used_at"),
+        createdAt: timestamp("created_at").defaultNow().notNull()
+    });
 
-/**
- * App config - key/value store for custom settings
- */
-export const appConfig = rebaseSchema.table("app_config", {
-    key: varchar("key", { length: 100 }).primaryKey(),
-    value: jsonb("value").notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-});
+    /**
+     * App config - key/value store for custom settings
+     */
+    const appConfig = rolesTableCreator("app_config", {
+        key: varchar("key", { length: 100 }).primaryKey(),
+        value: jsonb("value").notNull(),
+        updatedAt: timestamp("updated_at").defaultNow().notNull()
+    });
 
-/**
- * User identities - maps external OAuth profiles back to local users
- */
-export const userIdentities = rebaseSchema.table("user_identities", {
-    id: uuid("id").defaultRandom().primaryKey(),
-    userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
-    provider: varchar("provider", { length: 50 }).notNull(), // e.g. 'google', 'linkedin'
-    providerId: varchar("provider_id", { length: 255 }).notNull(),
-    profileData: jsonb("profile_data"),
-    createdAt: timestamp("created_at").defaultNow().notNull(),
-    updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => ({
-    uniqueProviderId: unique("unique_provider_id").on(table.provider, table.providerId)
-}));
+    /**
+     * User identities - maps external OAuth profiles back to local users
+     */
+    const userIdentities = rolesTableCreator("user_identities", {
+        id: uuid("id").defaultRandom().primaryKey(),
+        userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+        provider: varchar("provider", { length: 50 }).notNull(), // e.g. 'google', 'linkedin'
+        providerId: varchar("provider_id", { length: 255 }).notNull(),
+        profileData: jsonb("profile_data"),
+        createdAt: timestamp("created_at").defaultNow().notNull(),
+        updatedAt: timestamp("updated_at").defaultNow().notNull()
+    }, (table: any) => ({
+        uniqueProviderId: unique("unique_provider_id").on(table.provider, table.providerId)
+    }));
+
+    return {
+        rolesSchema,
+        usersSchema,
+        users,
+        roles,
+        userRoles,
+        refreshTokens,
+        passwordResetTokens,
+        appConfig,
+        userIdentities
+    };
+}
+
+// Instantiate default schema and tables using the default "rebase" schema
+const defaultAuthSchema = createAuthSchema("rebase", "rebase");
+
+export const rebaseSchema = defaultAuthSchema.rolesSchema;
+export const usersSchema = defaultAuthSchema.usersSchema;
+
+export const users = defaultAuthSchema.users;
+export const roles = defaultAuthSchema.roles;
+export const userRoles = defaultAuthSchema.userRoles;
+export const refreshTokens = defaultAuthSchema.refreshTokens;
+export const passwordResetTokens = defaultAuthSchema.passwordResetTokens;
+export const appConfig = defaultAuthSchema.appConfig;
+export const userIdentities = defaultAuthSchema.userIdentities;
 
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({

package/src/schema/default-collections.ts

@@ -0,0 +1,68 @@
+import { PostgresCollection } from "@rebasepro/types";
+
+export const defaultUsersCollection: PostgresCollection = {
+    name: "Users",
+    singularName: "User",
+    slug: "users",
+    table: "users",
+    icon: "Users",
+    group: "Settings",
+    properties: {
+        id: {
+            name: "ID",
+            type: "string",
+            isId: "uuid"
+        },
+        email: {
+            name: "Email",
+            type: "string",
+            validation: { required: true, unique: true }
+        },
+        password_hash: {
+            name: "Password Hash",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        display_name: {
+            name: "Display Name",
+            type: "string"
+        },
+        photo_url: {
+            name: "Photo URL",
+            type: "string"
+        },
+        email_verified: {
+            name: "Email Verified",
+            type: "boolean",
+            defaultValue: false
+        },
+        email_verification_token: {
+            name: "Email Verification Token",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        email_verification_sent_at: {
+            name: "Email Verification Sent At",
+            type: "date",
+            ui: { hideFromCollection: true }
+        },
+        metadata: {
+            name: "Metadata",
+            type: "map",
+            defaultValue: {},
+            ui: { hideFromCollection: true }
+        },
+        created_at: {
+            name: "Created At",
+            type: "date",
+            autoValue: "on_create",
+            ui: { readOnly: true, hideFromCollection: true }
+        },
+        updated_at: {
+            name: "Updated At",
+            type: "date",
+            autoValue: "on_update",
+            ui: { readOnly: true, hideFromCollection: true }
+        }
+    }
+};