community feature

packages/db/src/client.ts

@@ -0,0 +1,17 @@
+import { createClient } from '@supabase/supabase-js'
+import type { Database } from './types'
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
+const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY
+
+if (!supabaseUrl || !supabaseAnonKey) {
+  throw new Error(
+    'Missing Supabase environment variables. Add NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY to your .env.local file.'
+  )
+}
+
+/**
+ * Supabase client for client-side use with anon key
+ * Uses Row Level Security (RLS) policies
+ */
+export const supabase = createClient<Database>(supabaseUrl, supabaseAnonKey)

packages/db/src/drizzle.ts

@@ -0,0 +1,17 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+import * as schema from './schema'
+
+if (!process.env.POSTGRES_URL) {
+  throw new Error(
+    'Missing POSTGRES_URL environment variable. Add your Supabase database connection string.',
+  )
+}
+
+// Create postgres connection
+const client = postgres(process.env.POSTGRES_URL)
+
+// Create drizzle instance
+export const db = drizzle(client, { schema })
+
+export type Database = typeof db

packages/db/src/helpers.ts

@@ -0,0 +1,56 @@
+import { type AnyColumn, type SQL, sql } from 'drizzle-orm'
+import { text, timestamp } from 'drizzle-orm/pg-core'
+import { customAlphabet } from 'nanoid'
+
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+const nanoid = customAlphabet(alphabet, 16)
+
+/**
+ * Generate a unique ID with optional prefix
+ * @example createId('user') => 'user_Abc123...'
+ */
+export const createId = (prefix?: string) => {
+  const id = nanoid()
+  return prefix ? `${prefix}_${id}` : id
+}
+
+/**
+ * Primary key column with auto-generated prefixed ID
+ * @example id('user') => text('id').notNull().primaryKey().$defaultFn(() => createId('user'))
+ */
+export const id = (prefix?: string) =>
+  text('id')
+    .notNull()
+    .primaryKey()
+    .$defaultFn(() => createId(prefix))
+    .$type<string>()
+
+export const createdAt = timestamp('created_at', { withTimezone: true }).notNull().defaultNow()
+
+export const updatedAt = timestamp('updated_at', { withTimezone: true })
+  .notNull()
+  .defaultNow()
+  .$onUpdate(() => new Date())
+
+export const deletedAt = timestamp('deleted_at', { withTimezone: true })
+
+/**
+ * Standard timestamp columns for created_at and updated_at
+ */
+export const timestamps = {
+  createdAt,
+  updatedAt,
+}
+
+// Alias for backwards compatibility with existing code
+export const timestampsColumns = timestamps
+
+export const timestampsColumnsSoftDelete = {
+  ...timestampsColumns,
+  deletedAt,
+}
+
+/**
+ * SQL helper for case-insensitive comparison
+ */
+export const lower = (column: AnyColumn): SQL => sql`lower(${column})`

packages/db/src/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Database package
+ * Exports Supabase clients, Drizzle ORM, and types
+ */
+
+export { supabase } from './client'
+export { supabaseAdmin } from './server'
+export type { Database as SupabaseDatabase } from './types'
+
+// Drizzle exports
+export { type Database, db } from './drizzle'
+export * from './schema'
+
+import * as dbSchema from './schema'
+export const schema = dbSchema
+export {
+  createId,
+  deletedAt,
+  id,
+  lower,
+  timestamps,
+  timestampsColumns,
+  timestampsColumnsSoftDelete,
+} from './helpers'

packages/db/src/schema/auth/accounts.ts

@@ -0,0 +1,31 @@
+import { pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, timestamps } from '../../helpers'
+import { users } from './users'
+
+export const accounts = pgTable('auth_accounts', (t) => ({
+  id: id('account'),
+  userId: t
+    .text('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  providerId: t.text('provider_id').notNull(),
+  accountId: t.text('account_id').notNull(),
+  password: t.text('password'),
+  accessToken: t.text('access_token'),
+  refreshToken: t.text('refresh_token'),
+  idToken: t.text('id_token'),
+  accessTokenExpiresAt: t.timestamp('access_token_expires_at', {
+    withTimezone: true,
+  }),
+  refreshTokenExpiresAt: t.timestamp('refresh_token_expires_at', {
+    withTimezone: true,
+  }),
+  scope: t.text('scope'),
+  ...timestamps,
+})).enableRLS()
+
+export type Account = typeof accounts.$inferSelect
+export type NewAccount = typeof accounts.$inferInsert
+export const insertAccountSchema = createInsertSchema(accounts)
+export const selectAccountSchema = createSelectSchema(accounts)

packages/db/src/schema/auth/jwks.ts

@@ -0,0 +1,15 @@
+import { pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { createdAt, id } from '../../helpers'
+
+export const jwks = pgTable('auth_jwks', (t) => ({
+  id: id('jwks'),
+  publicKey: t.text('public_key').notNull(),
+  privateKey: t.text('private_key').notNull(),
+  createdAt,
+})).enableRLS()
+
+export type Jwks = typeof jwks.$inferSelect
+export type NewJwks = typeof jwks.$inferInsert
+export const insertJwksSchema = createInsertSchema(jwks)
+export const selectJwksSchema = createSelectSchema(jwks)

packages/db/src/schema/auth/sessions.ts

@@ -0,0 +1,28 @@
+import { pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, timestamps } from '../../helpers'
+import { users } from './users'
+
+export const sessions = pgTable('auth_sessions', (t) => ({
+  id: id('session'),
+  userId: t
+    .text('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  expiresAt: t.timestamp('expires_at', { withTimezone: true }),
+  token: t.text('token').notNull(),
+  ipAddress: t.text('ip_address'),
+  userAgent: t.text('user_agent'),
+  // Custom: active property for the session context
+  activePropertyId: t.text('active_property_id'),
+  // Admin plugin support: tracks who is impersonating this session
+  impersonatedBy: t
+    .text('impersonated_by')
+    .references(() => users.id, { onDelete: 'set null' }),
+  ...timestamps,
+})).enableRLS()
+
+export type Session = typeof sessions.$inferSelect
+export type NewSession = typeof sessions.$inferInsert
+export const insertSessionSchema = createInsertSchema(sessions)
+export const selectSessionSchema = createSelectSchema(sessions)

packages/db/src/schema/auth/users.ts

@@ -0,0 +1,28 @@
+import { pgEnum, pgTable, uniqueIndex } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, lower, timestampsColumns } from '../../helpers'
+
+export const USER_ROLES = ['user', 'admin'] as const
+export const userRoles = pgEnum('auth_user_roles', USER_ROLES)
+
+export const users = pgTable(
+  'auth_users',
+  (t) => ({
+    id: id('user'),
+    email: t.text('email').notNull(),
+    emailVerified: t.boolean('email_verified').notNull().default(false),
+    name: t.text('name').notNull(),
+    image: t.text('image'),
+    role: userRoles('role').notNull().default('user'),
+    banned: t.boolean('banned').notNull().default(false),
+    banReason: t.text('ban_reason'),
+    banExpires: t.timestamp('ban_expires', { withTimezone: true }),
+    ...timestampsColumns,
+  }),
+  (t) => [uniqueIndex('email_unique_index').on(lower(t.email))],
+).enableRLS()
+
+export type User = typeof users.$inferSelect
+export type NewUser = typeof users.$inferInsert
+export const insertUserSchema = createInsertSchema(users)
+export const selectUserSchema = createSelectSchema(users)

packages/db/src/schema/auth/verifications.ts

@@ -0,0 +1,22 @@
+import { index, pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, timestamps } from '../../helpers'
+
+export const verifications = pgTable(
+  'auth_verifications',
+  (t) => ({
+    id: id('verification'),
+    value: t.text('value').notNull(),
+    identifier: t.text('identifier').notNull(),
+    expiresAt: t.timestamp('expires_at', {
+      withTimezone: true,
+    }),
+    ...timestamps,
+  }),
+  (t) => [index('verification_identifier_index').on(t.identifier)],
+).enableRLS()
+
+export type Verification = typeof verifications.$inferSelect
+export type NewVerification = typeof verifications.$inferInsert
+export const insertVerificationSchema = createInsertSchema(verifications)
+export const selectVerificationSchema = createSelectSchema(verifications)

packages/db/src/schema/index.ts

@@ -0,0 +1,11 @@
+// Auth tables
+export * from './auth/accounts'
+export * from './auth/jwks'
+export * from './auth/sessions'
+export * from './auth/users'
+export * from './auth/verifications'
+
+// Property tables
+export * from './properties/addresses'
+export * from './properties/models'
+export * from './properties/properties'

packages/db/src/schema/properties/addresses.ts

@@ -0,0 +1,53 @@
+import { pgTable, unique } from 'drizzle-orm/pg-core'
+import { z } from 'zod'
+import { id, timestampsColumns } from '../../helpers'
+
+export const addresses = pgTable(
+  'properties_addresses',
+  (t) => ({
+    id: id('address'),
+    streetNumber: t.text('street_number'),
+    route: t.text('route'),
+    routeShort: t.text('route_short'),
+    neighborhood: t.text('neighborhood'),
+    city: t.text('city'),
+    county: t.text('county'),
+    state: t.text('state'),
+    stateLong: t.text('state_long'),
+    postalCode: t.text('postal_code'),
+    postalCodeSuffix: t.text('postal_code_suffix'),
+    country: t.text('country'),
+    countryLong: t.text('country_long'),
+    latitude: t.numeric('latitude'),
+    longitude: t.numeric('longitude'),
+    rawJson: t.jsonb('raw_json'),
+    ...timestampsColumns,
+  }),
+  (t) => [
+    // Unique constraint on core address components to prevent duplicates
+    unique('address_components_unique').on(t.streetNumber, t.route, t.city, t.state, t.postalCode),
+  ],
+).enableRLS()
+
+// Create address schema manually to avoid issues with generated columns
+export const addressSchema = z.object({
+  streetNumber: z.string().optional(),
+  route: z.string().optional(),
+  routeShort: z.string().optional(),
+  neighborhood: z.string().optional(),
+  city: z.string().optional(),
+  county: z.string().optional(),
+  state: z.string().optional(),
+  stateLong: z.string().optional(),
+  postalCode: z.string().optional(),
+  postalCodeSuffix: z.string().optional(),
+  country: z.string().default('US'),
+  countryLong: z.string().optional(),
+  latitude: z.string().optional(),
+  longitude: z.string().optional(),
+  rawJson: z.record(z.string(), z.unknown()).optional(),
+})
+
+export type AddressSchema = z.infer<typeof addressSchema>
+export type Address = typeof addresses.$inferSelect
+export type NewAddress = typeof addresses.$inferInsert

packages/db/src/schema/properties/models.ts

@@ -0,0 +1,31 @@
+import { relations } from 'drizzle-orm'
+import { pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, timestampsColumnsSoftDelete } from '../../helpers'
+import { properties } from './properties'
+
+export const models = pgTable('properties_models', (t) => ({
+  id: id('model'),
+  name: t.text('name'),
+  version: t.integer('version').default(1),
+  description: t.text('description'),
+  draft: t.boolean('draft').default(true),
+  propertyId: t
+    .text('property_id')
+    .references(() => properties.id, { onDelete: 'set null' }),
+  sceneGraph: t.jsonb('scene_graph'),
+  metadata: t.jsonb('metadata'),
+  ...timestampsColumnsSoftDelete,
+})).enableRLS()
+
+export const modelsRelations = relations(models, ({ one }) => ({
+  property: one(properties, {
+    fields: [models.propertyId],
+    references: [properties.id],
+  }),
+}))
+
+export type Model = typeof models.$inferSelect
+export type NewModel = typeof models.$inferInsert
+export const insertModelSchema = createInsertSchema(models)
+export const selectModelSchema = createSelectSchema(models)

packages/db/src/schema/properties/properties.ts

@@ -0,0 +1,44 @@
+import { relations } from 'drizzle-orm'
+import { index, pgTable } from 'drizzle-orm/pg-core'
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod'
+import { id, timestampsColumns } from '../../helpers'
+import { users } from '../auth/users'
+import { addresses } from './addresses'
+
+export const properties = pgTable(
+  'properties',
+  (t) => ({
+    id: id('property'),
+    name: t.text('name'),
+    addressId: t
+      .text('address_id')
+      .references(() => addresses.id, { onDelete: 'set null' })
+      .unique(),
+    ownerId: t
+      .text('owner_id')
+      .references(() => users.id, { onDelete: 'set null' }),
+    detailsJson: t.jsonb('details_json'),
+    metadata: t.jsonb('metadata'),
+    ...timestampsColumns,
+  }),
+  (t) => [
+    index('property_address_idx').on(t.addressId),
+    index('property_owner_idx').on(t.ownerId),
+  ],
+).enableRLS()
+
+export const propertiesRelations = relations(properties, ({ one }) => ({
+  address: one(addresses, {
+    fields: [properties.addressId],
+    references: [addresses.id],
+  }),
+  owner: one(users, {
+    fields: [properties.ownerId],
+    references: [users.id],
+  }),
+}))
+
+export type Property = typeof properties.$inferSelect
+export type NewProperty = typeof properties.$inferInsert
+export const insertPropertySchema = createInsertSchema(properties)
+export const selectPropertySchema = createSelectSchema(properties)

packages/db/src/server.ts

@@ -0,0 +1,23 @@
+import { createClient } from '@supabase/supabase-js'
+import type { Database } from './types'
+
+const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
+const supabaseServiceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY
+
+if (!supabaseUrl || !supabaseServiceRoleKey) {
+  throw new Error(
+    'Missing Supabase environment variables. Add NEXT_PUBLIC_SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY to your .env.local file.'
+  )
+}
+
+/**
+ * Supabase client for server-side use with service role key
+ * Bypasses Row Level Security (RLS) - use with caution
+ * Always filter by user_id to enforce permissions
+ */
+export const supabaseAdmin = createClient<Database>(supabaseUrl, supabaseServiceRoleKey, {
+  auth: {
+    persistSession: false,
+    autoRefreshToken: false,
+  },
+})

packages/db/src/types.ts

@@ -0,0 +1,124 @@
+/**
+ * Database types for Supabase
+ * Generated from database schema
+ */
+
+export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
+
+export interface Database {
+  public: {
+    Tables: {
+      properties: {
+        Row: {
+          id: string
+          name: string
+          owner_id: string
+          created_at: string
+          updated_at: string
+        }
+        Insert: {
+          id?: string
+          name: string
+          owner_id: string
+          created_at?: string
+          updated_at?: string
+        }
+        Update: {
+          id?: string
+          name?: string
+          owner_id?: string
+          created_at?: string
+          updated_at?: string
+        }
+      }
+      properties_addresses: {
+        Row: {
+          id: string
+          property_id: string
+          formatted_address: string
+          street_number: string | null
+          route: string | null
+          locality: string | null
+          administrative_area_level_1: string | null
+          administrative_area_level_2: string | null
+          country: string | null
+          postal_code: string | null
+          latitude: number | null
+          longitude: number | null
+          place_id: string | null
+          created_at: string
+          updated_at: string
+        }
+        Insert: {
+          id?: string
+          property_id: string
+          formatted_address: string
+          street_number?: string | null
+          route?: string | null
+          locality?: string | null
+          administrative_area_level_1?: string | null
+          administrative_area_level_2?: string | null
+          country?: string | null
+          postal_code?: string | null
+          latitude?: number | null
+          longitude?: number | null
+          place_id?: string | null
+          created_at?: string
+          updated_at?: string
+        }
+        Update: {
+          id?: string
+          property_id?: string
+          formatted_address?: string
+          street_number?: string | null
+          route?: string | null
+          locality?: string | null
+          administrative_area_level_1?: string | null
+          administrative_area_level_2?: string | null
+          country?: string | null
+          postal_code?: string | null
+          latitude?: number | null
+          longitude?: number | null
+          place_id?: string | null
+          created_at?: string
+          updated_at?: string
+        }
+      }
+      properties_models: {
+        Row: {
+          id: string
+          property_id: string
+          name: string
+          version: number
+          draft: boolean
+          scene_graph: Json | null
+          created_at: string
+          updated_at: string
+        }
+        Insert: {
+          id?: string
+          property_id: string
+          name: string
+          version?: number
+          draft?: boolean
+          scene_graph?: Json | null
+          created_at?: string
+          updated_at?: string
+        }
+        Update: {
+          id?: string
+          property_id?: string
+          name?: string
+          version?: number
+          draft?: boolean
+          scene_graph?: Json | null
+          created_at?: string
+          updated_at?: string
+        }
+      }
+    }
+    Views: {}
+    Functions: {}
+    Enums: {}
+  }
+}