@rebasepro/server-postgresql 0.2.4 → 0.2.5

package/src/schema/auth-schema.ts

@@ -1,15 +1,14 @@
-import { pgSchema, pgTable, varchar, uuid, timestamp, boolean, jsonb, primaryKey, unique } from "drizzle-orm/pg-core";
+import { pgSchema, pgTable, varchar, uuid, timestamp, boolean, jsonb, text, unique } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
 
 /**
  * Factory function to dynamically create the auth tables bound to the specified schema names.
  */
-export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchemaName: string = "rebase") {
-    const rolesSchema = rolesSchemaName === "public" ? null : pgSchema(rolesSchemaName);
+export function createAuthSchema(usersSchemaName: string = "rebase") {
     const usersSchema = usersSchemaName === "public" ? null : pgSchema(usersSchemaName);
 
-    const rolesTableCreator = (rolesSchema ? rolesSchema.table.bind(rolesSchema) : pgTable) as typeof pgTable;
-    const usersTableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
+    const tableCreator = (usersSchema ? usersSchema.table.bind(usersSchema) : pgTable) as typeof pgTable;
+    const usersTableCreator = tableCreator;
 
     /**
      * Users table - stores both email/password and OAuth users
@@ -24,48 +23,18 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
         emailVerificationToken: varchar("email_verification_token", { length: 255 }),
         emailVerificationSentAt: timestamp("email_verification_sent_at"),
         isAnonymous: boolean("is_anonymous").default(false).notNull(),
+        roles: text("roles").array().default([]).notNull(),
         metadata: jsonb("metadata").$type<Record<string, unknown>>().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;
-        }>(),
-        collectionPermissions: jsonb("collection_permissions").$type<
-            Record<string, {
-                read?: boolean;
-                create?: boolean;
-                edit?: boolean;
-                delete?: boolean;
-            }>
-        >()
-    });
 
-    /**
-     * 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) => ({
-        pk: primaryKey({ columns: [table.userId, table.roleId] })
-    }));
 
     /**
      * Refresh tokens for long-lived sessions
      */
-    const refreshTokens = rolesTableCreator("refresh_tokens", {
+    const refreshTokens = tableCreator("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(),
@@ -80,7 +49,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * Password reset tokens for forgot password flow
      */
-    const passwordResetTokens = rolesTableCreator("password_reset_tokens", {
+    const passwordResetTokens = tableCreator("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(),
@@ -92,7 +61,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * App config - key/value store for custom settings
      */
-    const appConfig = rolesTableCreator("app_config", {
+    const appConfig = tableCreator("app_config", {
         key: varchar("key", { length: 100 }).primaryKey(),
         value: jsonb("value").notNull(),
         updatedAt: timestamp("updated_at").defaultNow().notNull()
@@ -101,7 +70,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * User identities - maps external OAuth profiles back to local users
      */
-    const userIdentities = rolesTableCreator("user_identities", {
+    const userIdentities = tableCreator("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'
@@ -116,7 +85,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * MFA factors table - stores enrolled MFA methods
      */
-    const mfaFactors = rolesTableCreator("mfa_factors", {
+    const mfaFactors = tableCreator("mfa_factors", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         factorType: varchar("factor_type", { length: 20 }).notNull(), // 'totp'
@@ -130,7 +99,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * MFA challenges table - tracks active MFA verification attempts
      */
-    const mfaChallenges = rolesTableCreator("mfa_challenges", {
+    const mfaChallenges = tableCreator("mfa_challenges", {
         id: uuid("id").defaultRandom().primaryKey(),
         factorId: uuid("factor_id").notNull().references(() => mfaFactors.id, { onDelete: "cascade" }),
         createdAt: timestamp("created_at").defaultNow().notNull(),
@@ -142,7 +111,7 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     /**
      * Recovery codes table - backup codes for MFA
      */
-    const recoveryCodes = rolesTableCreator("recovery_codes", {
+    const recoveryCodes = tableCreator("recovery_codes", {
         id: uuid("id").defaultRandom().primaryKey(),
         userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
         codeHash: varchar("code_hash", { length: 255 }).notNull(),
@@ -151,11 +120,8 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
     });
 
     return {
-        rolesSchema,
         usersSchema,
         users,
-        roles,
-        userRoles,
         refreshTokens,
         passwordResetTokens,
         appConfig,
@@ -167,14 +133,11 @@ export function createAuthSchema(rolesSchemaName: string = "rebase", usersSchema
 }
 
 // Instantiate default schema and tables using the default "rebase" schema
-const defaultAuthSchema = createAuthSchema("rebase", "rebase");
+const defaultAuthSchema = createAuthSchema("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;
@@ -185,7 +148,6 @@ export const recoveryCodes = defaultAuthSchema.recoveryCodes;
 
 // Relations
 export const usersRelations = relations(users, ({ many }) => ({
-    userRoles: many(userRoles),
     refreshTokens: many(refreshTokens),
     passwordResetTokens: many(passwordResetTokens),
     userIdentities: many(userIdentities),
@@ -193,21 +155,6 @@ export const usersRelations = relations(users, ({ many }) => ({
     recoveryCodes: many(recoveryCodes)
 }));
 
-export const rolesRelations = relations(roles, ({ many }) => ({
-    userRoles: many(userRoles)
-}));
-
-export const userRolesRelations = relations(userRoles, ({ one }) => ({
-    user: one(users, {
-        fields: [userRoles.userId],
-        references: [users.id]
-    }),
-    role: one(roles, {
-        fields: [userRoles.roleId],
-        references: [roles.id]
-    })
-}));
-
 export const refreshTokensRelations = relations(refreshTokens, ({ one }) => ({
     user: one(users, {
         fields: [refreshTokens.userId],
@@ -254,9 +201,6 @@ export const recoveryCodesRelations = relations(recoveryCodes, ({ one }) => ({
 // Type exports
 export type User = typeof users.$inferSelect;
 export type NewUser = typeof users.$inferInsert;
-export type Role = typeof roles.$inferSelect;
-export type NewRole = typeof roles.$inferInsert;
-export type UserRole = typeof userRoles.$inferSelect;
 export type RefreshToken = typeof refreshTokens.$inferSelect;
 export type PasswordResetToken = typeof passwordResetTokens.$inferSelect;
 export type AppConfig = typeof appConfig.$inferSelect;

package/src/schema/doctor.ts

@@ -84,10 +84,28 @@ export function getExpectedColumnType(prop: Property): string | null {
             if (dp.columnType === "time") return "time without time zone";
             return "timestamp with time zone";
         }
-        case "map":
         case "array": {
-            const ap = prop as ArrayProperty | MapProperty;
-            if (ap.columnType === "json") return "json";
+            const ap = prop as ArrayProperty;
+            let colType = ap.columnType;
+            if (!colType && ap.of && !Array.isArray(ap.of)) {
+                const ofProp = ap.of as Property;
+                if (ofProp.type === "string") {
+                    colType = "text[]";
+                } else if (ofProp.type === "number") {
+                    colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                } else if (ofProp.type === "boolean") {
+                    colType = "boolean[]";
+                }
+            }
+
+            if (colType === "json") return "json";
+            if (colType === "jsonb") return "jsonb";
+            if (colType && colType.endsWith("[]")) return "ARRAY";
+            return "jsonb";
+        }
+        case "map": {
+            const mp = prop as MapProperty;
+            if (mp.columnType === "json") return "json";
             return "jsonb";
         }
         case "relation":
@@ -485,6 +503,29 @@ export async function checkCollectionsVsDatabase(
                     if (prop.type === "vector" && dbCol.udt_name !== "vector") {
                         isMismatch = true;
                     }
+                    if (prop.type === "array") {
+                        const ap = prop as ArrayProperty;
+                        let expectedColType = ap.columnType;
+                        if (!expectedColType && ap.of && !Array.isArray(ap.of)) {
+                            const ofProp = ap.of as Property;
+                            if (ofProp.type === "string") expectedColType = "text[]";
+                            else if (ofProp.type === "number") expectedColType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                            else if (ofProp.type === "boolean") expectedColType = "boolean[]";
+                        }
+                        if (expectedColType && expectedColType.endsWith("[]")) {
+                            if (actualType !== "ARRAY") {
+                                isMismatch = true;
+                            } else {
+                                const expectedUdt = expectedColType === "text[]" ? "_text" :
+                                                    expectedColType === "integer[]" ? "_int4" :
+                                                    expectedColType === "boolean[]" ? "_bool" :
+                                                    expectedColType === "numeric[]" ? "_numeric" : "";
+                                if (expectedUdt && dbCol.udt_name !== expectedUdt) {
+                                    isMismatch = true;
+                                }
+                            }
+                        }
+                    }
                     if (isMismatch) {
                         issues.push({
                             severity: "warning",

package/src/schema/generate-drizzle-schema-logic.ts

@@ -70,6 +70,8 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 columnDefinition = `${enumName}("${colName}")`;
             } else if ("isId" in stringProp && stringProp.isId === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
+            } else if (stringProp.columnType === "uuid") {
+                columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "text") {
                 columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
@@ -145,11 +147,39 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             break;
         }
-        case "map":
+        case "map": {
+            const mapProp = prop as MapProperty;
+            if (mapProp.columnType === "json") {
+                columnDefinition = `json("${colName}")`;
+            } else {
+                columnDefinition = `jsonb("${colName}")`;
+            }
+            break;
+        }
         case "array": {
-            const arrayOrMapProp = prop as ArrayProperty | MapProperty;
-            if (arrayOrMapProp.columnType === "json") {
+            const arrayProp = prop as ArrayProperty;
+            let colType = arrayProp.columnType;
+            if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
+                const ofProp = arrayProp.of as Property;
+                if (ofProp.type === "string") {
+                    colType = "text[]";
+                } else if (ofProp.type === "number") {
+                    colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                } else if (ofProp.type === "boolean") {
+                    colType = "boolean[]";
+                }
+            }
+
+            if (colType === "json") {
                 columnDefinition = `json("${colName}")`;
+            } else if (colType === "text[]") {
+                columnDefinition = `text("${colName}").array()`;
+            } else if (colType === "integer[]") {
+                columnDefinition = `integer("${colName}").array()`;
+            } else if (colType === "boolean[]") {
+                columnDefinition = `boolean("${colName}").array()`;
+            } else if (colType === "numeric[]") {
+                columnDefinition = `numeric("${colName}").array()`;
             } else {
                 columnDefinition = `jsonb("${colName}")`;
             }

package/src/schema/introspect-db-logic.ts

@@ -589,9 +589,16 @@ export function generateCollectionFile(
         // Array/Map heuristics (Fallback if not inferred)
         if (finalPropType === "array" && !inferenceExtra.includes("of: {")) {
             let innerType = "string";
+            let colType = "";
             if (col.udt_name.startsWith("_")) {
                 const baseType = col.udt_name.substring(1);
                 innerType = mapPgType(baseType);
+                if (innerType === "string") colType = "text[]";
+                else if (innerType === "number") colType = col.udt_name === "_numeric" ? "numeric[]" : "integer[]";
+                else if (innerType === "boolean") colType = "boolean[]";
+            }
+            if (colType) {
+                extra += `\n            columnType: "${colType}",`;
             }
             extra += `\n            of: { name: "${humanize(col.column_name)} Item", type: "${innerType}" },`;
         } else if (finalPropType === "map" && !inferenceExtra.includes("keyValue: true") && !inferenceExtra.includes("properties: {")) {

package/src/services/EntityPersistService.ts

@@ -53,6 +53,15 @@ export class EntityPersistService {
             .where(eq(idField, parsedId));
     }
 
+    /**
+     * Delete all entities from a collection
+     */
+    async deleteAll(collectionPath: string, _databaseId?: string): Promise<void> {
+        const collection = getCollectionByPath(collectionPath, this.registry);
+        const table = getTableForCollection(collection, this.registry);
+        await this.db.delete(table);
+    }
+
     /**
      * Save an entity (create or update)
      */

package/src/services/entityService.ts

@@ -169,6 +169,13 @@ export class EntityService implements EntityRepository {
         return this.persistService.deleteEntity(collectionPath, entityId, databaseId);
     }
 
+    /**
+     * Delete all entities from a collection
+     */
+    async deleteAll(collectionPath: string, databaseId?: string): Promise<void> {
+        return this.persistService.deleteAll(collectionPath, databaseId);
+    }
+
 
     /**
      * Execute raw SQL

package/test/auth-services.test.ts

@@ -1,5 +1,5 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { UserService, RoleService, RefreshTokenService, PasswordResetTokenService, Role } from "../src/auth/services";
+import { UserService, RefreshTokenService, PasswordResetTokenService, Role } from "../src/auth/services";
 import { users, refreshTokens, passwordResetTokens } from "../src/schema/auth-schema";
 import { UserData } from "@rebasepro/server-core";
 
@@ -344,18 +344,7 @@ describe("Auth Services", () => {
         describe("getUserRoles", () => {
             it("should return roles for user", async () => {
                 mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-                            name: "Admin",
-                            is_admin: true,
-                            default_permissions: null,
-                            collection_permissions: null },
-                        { id: "editor",
-                            name: "Editor",
-                            is_admin: false,
-                            default_permissions: { edit: true },
-                            collection_permissions: null }
-                    ]
+                    rows: [{ roles: ["admin", "editor"] }]
                 });
 
                 const roles = await userService.getUserRoles("user-123");
@@ -363,7 +352,7 @@ describe("Auth Services", () => {
                 expect(roles).toHaveLength(2);
                 expect(roles[0]).toEqual({
                     id: "admin",
-                    name: "Admin",
+                    name: "admin",
                     isAdmin: true,
                     defaultPermissions: null,
                     collectionPermissions: null
@@ -374,13 +363,7 @@ describe("Auth Services", () => {
         describe("getUserRoleIds", () => {
             it("should return role IDs for user", async () => {
                 mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-                            name: "Admin",
-                            is_admin: true,
-                            default_permissions: null,
-                            collection_permissions: null }
-                    ]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const roleIds = await userService.getUserRoleIds("user-123");
@@ -393,10 +376,7 @@ describe("Auth Services", () => {
             it("should delete existing and insert new roles", async () => {
                 await userService.setUserRoles("user-123", ["admin", "editor"]);
 
-                // First call deletes existing roles
                 expect(mockExecute).toHaveBeenCalled();
-                // Subsequent calls insert new roles
-                expect(mockExecute.mock.calls.length).toBeGreaterThanOrEqual(1);
             });
         });
 
@@ -408,7 +388,7 @@ describe("Auth Services", () => {
             });
 
             it("should use editor as default role", async () => {
-                await userService.assignDefaultRole("user-123");
+                await userService.assignDefaultRole("user-123", "editor");
 
                 expect(mockExecute).toHaveBeenCalled();
             });
@@ -419,11 +399,7 @@ describe("Auth Services", () => {
                 const mockUser = { id: "user-123", email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
                 mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "admin",
-                        name: "Admin",
-                        is_admin: true,
-                        default_permissions: null,
-                        collection_permissions: null }]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const result = await userService.getUserWithRoles("user-123");
@@ -431,7 +407,7 @@ describe("Auth Services", () => {
                 expect(result).toEqual({
                     user: mockUserData({}),
                     roles: [{ id: "admin",
-                        name: "Admin",
+                        name: "admin",
                         isAdmin: true,
                         defaultPermissions: null,
                         collectionPermissions: null }]
@@ -472,125 +448,6 @@ describe("Auth Services", () => {
         });
     });
 
-    describe("RoleService", () => {
-        let roleService: RoleService;
-
-        beforeEach(() => {
-            roleService = new RoleService(db);
-        });
-
-        describe("getRoleById", () => {
-            it("should return role when found", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null }]
-                });
-
-                const result = await roleService.getRoleById("admin");
-
-                expect(result).toEqual({
-                    id: "admin",
-                    name: "Admin",
-                    isAdmin: true,
-                    defaultPermissions: null,
-                    collectionPermissions: null
-                });
-            });
-
-            it("should return null when role not found", async () => {
-                mockExecute.mockResolvedValueOnce({ rows: [] });
-
-                const result = await roleService.getRoleById("nonexistent");
-
-                expect(result).toBeNull();
-            });
-        });
-
-        describe("listRoles", () => {
-            it("should return all roles", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null },
-                        { id: "editor",
-name: "Editor",
-is_admin: false,
-default_permissions: null,
-collection_permissions: null }
-                    ]
-                });
-
-                const roles = await roleService.listRoles();
-
-                expect(roles).toHaveLength(2);
-            });
-        });
-
-        describe("createRole", () => {
-            it("should create a role", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "custom",
-name: "Custom Role",
-is_admin: false,
-default_permissions: null,
-collection_permissions: null }]
-                });
-
-                const role = await roleService.createRole({
-                    id: "custom",
-                    name: "Custom Role",
-                    defaultPermissions: null
-                });
-
-                expect(role.id).toBe("custom");
-                expect(role.name).toBe("Custom Role");
-            });
-        });
-
-        describe("updateRole", () => {
-            it("should update a role", async () => {
-                mockExecute
-                    .mockResolvedValueOnce({ rows: [{ id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null }] })
-                    .mockResolvedValueOnce({ rows: [] })
-                    .mockResolvedValueOnce({ rows: [{ id: "admin",
-name: "Super Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null }] });
-
-                const result = await roleService.updateRole("admin", { name: "Super Admin" });
-
-                expect(result?.name).toBe("Super Admin");
-            });
-
-            it("should return null when role not found", async () => {
-                mockExecute.mockResolvedValueOnce({ rows: [] });
-
-                const result = await roleService.updateRole("nonexistent", { name: "Test" });
-
-                expect(result).toBeNull();
-            });
-        });
-
-        describe("deleteRole", () => {
-            it("should delete a role", async () => {
-                await roleService.deleteRole("custom");
-
-                expect(mockExecute).toHaveBeenCalled();
-            });
-        });
-    });
-
     describe("RefreshTokenService", () => {
         let refreshTokenService: RefreshTokenService;
 

package/test/doctor.test.ts

@@ -135,8 +135,12 @@ columnType: "time" } as DateProperty)).toBe("time without time zone");
         it("should map json types correctly", () => {
             expect(getExpectedColumnType({ type: "map" })).toBe("jsonb");
             expect(getExpectedColumnType({ type: "array" })).toBe("jsonb");
-            expect(getExpectedColumnType({ type: "array",
-columnType: "json" } as ArrayProperty)).toBe("json");
+            expect(getExpectedColumnType({ type: "array", columnType: "json" } as ArrayProperty)).toBe("json");
+            
+            // Native array element type mappings
+            expect(getExpectedColumnType({ type: "array", of: { type: "string" } } as ArrayProperty)).toBe("ARRAY");
+            expect(getExpectedColumnType({ type: "array", of: { type: "number", validation: { integer: true } } } as ArrayProperty)).toBe("ARRAY");
+            expect(getExpectedColumnType({ type: "array", of: { type: "boolean" } } as ArrayProperty)).toBe("ARRAY");
         });
 
         it("should map enum string to USER-DEFINED", () => {

package/dist/server-postgresql/src/schema/default-collections.d.ts

@@ -1,2 +0,0 @@
-import { PostgresCollection } from "@rebasepro/types";
-export declare const defaultUsersCollection: PostgresCollection;

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

@@ -1,14 +0,0 @@
-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;
-};

package/src/schema/default-collections.ts

@@ -1,69 +0,0 @@
-import { PostgresCollection } from "@rebasepro/types";
-
-export const defaultUsersCollection: PostgresCollection = {
-    name: "Users",
-    singularName: "User",
-    slug: "users",
-    table: "users",
-    schema: "rebase",
-    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 }
-        }
-    }
-};