@qwickapps/server 1.6.1 → 1.7.1

package/src/plugins/tenants/stores/in-memory-store.ts

@@ -0,0 +1,335 @@
+/**
+ * In-memory Tenant Store for Demo/Testing
+ *
+ * Implements the TenantStore interface with in-memory storage.
+ * Pre-populated with demo tenants and memberships.
+ */
+
+import type {
+  Tenant,
+  TenantStore,
+  CreateTenantInput,
+  UpdateTenantInput,
+  TenantSearchParams,
+  TenantListResponse,
+  TenantMembership,
+  CreateTenantMembershipInput,
+  UpdateTenantMembershipInput,
+  TenantWithMembership,
+  TenantType,
+} from '../types.js';
+
+/**
+ * Default demo user ID used for pre-populated tenants.
+ * Matches the user ID assigned by basic auth guard.
+ */
+export const DEMO_USER_ID = 'basic-auth-user';
+
+/**
+ * Logger interface for in-memory stores.
+ */
+export interface InMemoryStoreLogger {
+  info: (message: string) => void;
+  debug?: (message: string) => void;
+}
+
+/**
+ * Options for creating an in-memory tenant store.
+ */
+export interface InMemoryTenantStoreOptions {
+  /**
+   * Demo user ID for pre-populated tenants.
+   * @default 'basic-auth-user'
+   */
+  demoUserId?: string;
+
+  /**
+   * Optional logger for store operations.
+   * If not provided, uses console.log as fallback.
+   */
+  logger?: InMemoryStoreLogger;
+}
+
+/**
+ * Creates an in-memory tenant store for demo/testing purposes.
+ * Pre-populated with 4 demo tenants (organization, group, department, user).
+ *
+ * This store is NOT suitable for production use - data is lost on restart.
+ * Use postgresTenantsStore for production deployments.
+ *
+ * @param options - Configuration options for the store
+ * @returns TenantStore implementation with in-memory storage
+ *
+ * @example
+ * ```typescript
+ * import { createInMemoryTenantStore } from '@qwickapps/server';
+ *
+ * const store = createInMemoryTenantStore({
+ *   demoUserId: 'test-user-123',
+ *   logger: console,
+ * });
+ *
+ * await store.initialize();
+ * const tenants = await store.getTenantsForUser('test-user-123');
+ * ```
+ */
+export function createInMemoryTenantStore(
+  options: InMemoryTenantStoreOptions = {}
+): TenantStore {
+  const demoUserId = options.demoUserId || DEMO_USER_ID;
+  const logger = options.logger || {
+    info: (msg: string) => console.log(msg),
+    debug: (msg: string) => console.log(msg),
+  };
+
+  const tenants = new Map<string, Tenant>();
+  const memberships = new Map<string, TenantMembership>();
+  let tenantIdCounter = 1;
+  let membershipIdCounter = 1;
+
+  // Pre-populate demo tenants
+  const demoTenants: Array<{ name: string; type: TenantType; owner_id: string }> = [
+    { name: 'Acme Corporation', type: 'organization', owner_id: demoUserId },
+    { name: 'Engineering Team', type: 'group', owner_id: demoUserId },
+    { name: 'Finance Department', type: 'department', owner_id: demoUserId },
+    { name: 'Demo User Workspace', type: 'user', owner_id: demoUserId },
+  ];
+
+  demoTenants.forEach((t) => {
+    const id = `tenant-${tenantIdCounter++}`;
+    const tenant: Tenant = {
+      id,
+      name: t.name,
+      type: t.type,
+      owner_id: t.owner_id,
+      metadata: {},
+      created_at: new Date(),
+      updated_at: new Date(),
+    };
+    tenants.set(id, tenant);
+
+    // Auto-create membership for owner
+    const membershipId = `membership-${membershipIdCounter++}`;
+    const membership: TenantMembership = {
+      id: membershipId,
+      tenant_id: id,
+      user_id: t.owner_id,
+      role: 'owner',
+      joined_at: new Date(),
+    };
+    memberships.set(membershipId, membership);
+  });
+
+  return {
+    name: 'in-memory',
+
+    async initialize(): Promise<void> {
+      logger.info('[InMemoryTenantStore] Initialized with demo tenants');
+    },
+
+    async getById(id: string): Promise<Tenant | null> {
+      return tenants.get(id) || null;
+    },
+
+    async getByIds(ids: string[]): Promise<Tenant[]> {
+      return ids.map((id) => tenants.get(id)).filter((t): t is Tenant => t !== undefined);
+    },
+
+    async getByName(name: string): Promise<Tenant | null> {
+      for (const tenant of tenants.values()) {
+        if (tenant.name.toLowerCase() === name.toLowerCase()) {
+          return tenant;
+        }
+      }
+      return null;
+    },
+
+    async create(input: CreateTenantInput): Promise<Tenant> {
+      const id = `tenant-${tenantIdCounter++}`;
+      const tenant: Tenant = {
+        id,
+        name: input.name,
+        type: input.type,
+        owner_id: input.owner_id,
+        metadata: input.metadata || {},
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      tenants.set(id, tenant);
+
+      // Auto-create membership for owner
+      const membershipId = `membership-${membershipIdCounter++}`;
+      const membership: TenantMembership = {
+        id: membershipId,
+        tenant_id: id,
+        user_id: input.owner_id,
+        role: 'owner',
+        joined_at: new Date(),
+      };
+      memberships.set(membershipId, membership);
+
+      return tenant;
+    },
+
+    async update(id: string, input: UpdateTenantInput): Promise<Tenant | null> {
+      const tenant = tenants.get(id);
+      if (!tenant) return null;
+
+      const updated: Tenant = {
+        ...tenant,
+        ...input,
+        id: tenant.id, // Preserve ID
+        created_at: tenant.created_at, // Preserve created_at
+        updated_at: new Date(),
+      };
+      tenants.set(id, updated);
+      return updated;
+    },
+
+    async delete(id: string): Promise<boolean> {
+      // Delete all memberships for this tenant
+      for (const [key, membership] of memberships.entries()) {
+        if (membership.tenant_id === id) {
+          memberships.delete(key);
+        }
+      }
+      return tenants.delete(id);
+    },
+
+    async search(params: TenantSearchParams = {}): Promise<TenantListResponse> {
+      let result = Array.from(tenants.values());
+
+      if (params.query) {
+        const query = params.query.toLowerCase();
+        result = result.filter((t) => t.name.toLowerCase().includes(query));
+      }
+
+      if (params.type) {
+        result = result.filter((t) => t.type === params.type);
+      }
+
+      if (params.owner_id) {
+        result = result.filter((t) => t.owner_id === params.owner_id);
+      }
+
+      const sortBy = params.sortBy || 'created_at';
+      const sortOrder = params.sortOrder || 'desc';
+
+      result.sort((a, b) => {
+        const aVal = a[sortBy as keyof Tenant];
+        const bVal = b[sortBy as keyof Tenant];
+        if (aVal == null || bVal == null) return 0;
+        if (aVal < bVal) return sortOrder === 'asc' ? -1 : 1;
+        if (aVal > bVal) return sortOrder === 'asc' ? 1 : -1;
+        return 0;
+      });
+
+      const total = result.length;
+      const page = params.page || 1;
+      const limit = params.limit || 20;
+      const offset = (page - 1) * limit;
+      result = result.slice(offset, offset + limit);
+
+      return {
+        tenants: result,
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      };
+    },
+
+    async getTenantsForUser(userId: string): Promise<TenantWithMembership[]> {
+      const userMemberships = Array.from(memberships.values()).filter(
+        (m) => m.user_id === userId
+      );
+      const results: TenantWithMembership[] = [];
+      for (const membership of userMemberships) {
+        const tenant = tenants.get(membership.tenant_id);
+        if (tenant) {
+          results.push({
+            ...tenant,
+            user_role: membership.role,
+            membership,
+          });
+        }
+      }
+      return results;
+    },
+
+    async getTenantForUser(
+      tenantId: string,
+      userId: string
+    ): Promise<TenantWithMembership | null> {
+      const membership = await this.getMembership(tenantId, userId);
+      if (!membership) return null;
+
+      const tenant = tenants.get(tenantId);
+      if (!tenant) return null;
+
+      return {
+        ...tenant,
+        user_role: membership.role,
+        membership,
+      };
+    },
+
+    async getMembers(tenantId: string): Promise<TenantMembership[]> {
+      return Array.from(memberships.values()).filter((m) => m.tenant_id === tenantId);
+    },
+
+    async getMembership(tenantId: string, userId: string): Promise<TenantMembership | null> {
+      for (const membership of memberships.values()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          return membership;
+        }
+      }
+      return null;
+    },
+
+    async addMember(input: CreateTenantMembershipInput): Promise<TenantMembership> {
+      const id = `membership-${membershipIdCounter++}`;
+      const membership: TenantMembership = {
+        id,
+        tenant_id: input.tenant_id,
+        user_id: input.user_id,
+        role: input.role,
+        joined_at: new Date(),
+      };
+      memberships.set(id, membership);
+      return membership;
+    },
+
+    async updateMember(
+      tenantId: string,
+      userId: string,
+      input: UpdateTenantMembershipInput
+    ): Promise<TenantMembership | null> {
+      for (const membership of memberships.values()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          const updated: TenantMembership = {
+            ...membership,
+            ...input,
+          };
+          memberships.set(membership.id, updated);
+          return updated;
+        }
+      }
+      return null;
+    },
+
+    async removeMember(tenantId: string, userId: string): Promise<boolean> {
+      for (const [key, membership] of memberships.entries()) {
+        if (membership.tenant_id === tenantId && membership.user_id === userId) {
+          memberships.delete(key);
+          return true;
+        }
+      }
+      return false;
+    },
+
+    async shutdown(): Promise<void> {
+      logger.info('[InMemoryTenantStore] Shutdown');
+    },
+  };
+}

package/src/plugins/tenants/stores/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Tenant Stores Index
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+export { postgresTenantStore } from './postgres-store.js';
+export {
+  createInMemoryTenantStore as inMemoryTenantStore,
+  DEMO_USER_ID,
+  type InMemoryStoreLogger,
+  type InMemoryTenantStoreOptions,
+} from './in-memory-store.js';

package/src/plugins/tenants/stores/postgres-store.ts

@@ -0,0 +1,370 @@
+/**
+ * PostgreSQL Tenant Store
+ *
+ * Tenant storage implementation using PostgreSQL.
+ * Requires the 'pg' package to be installed.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+import type {
+  TenantStore,
+  Tenant,
+  CreateTenantInput,
+  UpdateTenantInput,
+  TenantSearchParams,
+  TenantListResponse,
+  TenantMembership,
+  CreateTenantMembershipInput,
+  UpdateTenantMembershipInput,
+  TenantWithMembership,
+  PostgresTenantStoreConfig,
+} from '../types.js';
+
+// Pool interface (from pg package)
+interface PgPool {
+  query(text: string, values?: unknown[]): Promise<{ rows: unknown[]; rowCount: number | null }>;
+}
+
+/**
+ * Create a PostgreSQL tenant store
+ *
+ * @param config Configuration including a pg Pool instance
+ * @returns TenantStore implementation
+ *
+ * @example
+ * ```ts
+ * import { Pool } from 'pg';
+ * import { postgresTenantStore } from '@qwickapps/server';
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const store = postgresTenantStore({ pool });
+ * ```
+ */
+export function postgresTenantStore(config: PostgresTenantStoreConfig): TenantStore {
+  const {
+    pool: poolOrFn,
+    tenantsTable = 'tenants',
+    membershipsTable = 'tenant_memberships',
+    schema = 'public',
+    autoCreateTables = true,
+  } = config;
+
+  // Helper to get pool (supports lazy initialization via function)
+  const getPool = (): PgPool => {
+    const pool = typeof poolOrFn === 'function' ? poolOrFn() : poolOrFn;
+    return pool as PgPool;
+  };
+
+  const tenantsTableFull = `"${schema}"."${tenantsTable}"`;
+  const membershipsTableFull = `"${schema}"."${membershipsTable}"`;
+
+  return {
+    name: 'postgres',
+
+    async initialize(): Promise<void> {
+      if (!autoCreateTables) return;
+
+      try {
+        // Create tenants table
+        await getPool().query(`
+          CREATE TABLE IF NOT EXISTS ${tenantsTableFull} (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            name VARCHAR(255) NOT NULL,
+            type VARCHAR(50) NOT NULL,
+            owner_id UUID NOT NULL,
+            metadata JSONB DEFAULT '{}',
+            created_at TIMESTAMPTZ DEFAULT NOW(),
+            updated_at TIMESTAMPTZ DEFAULT NOW()
+          );
+        `);
+
+        // Create tenant memberships table
+        await getPool().query(`
+          CREATE TABLE IF NOT EXISTS ${membershipsTableFull} (
+            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+            tenant_id UUID NOT NULL REFERENCES ${tenantsTableFull}(id) ON DELETE CASCADE,
+            user_id UUID NOT NULL,
+            role VARCHAR(50) NOT NULL,
+            joined_at TIMESTAMPTZ DEFAULT NOW(),
+            UNIQUE(tenant_id, user_id)
+          );
+        `);
+
+        // Create indexes
+        await getPool().query(`
+          CREATE INDEX IF NOT EXISTS idx_${tenantsTable}_name ON ${tenantsTableFull}(name);
+          CREATE INDEX IF NOT EXISTS idx_${tenantsTable}_type ON ${tenantsTableFull}(type);
+          CREATE INDEX IF NOT EXISTS idx_${tenantsTable}_owner ON ${tenantsTableFull}(owner_id);
+          CREATE INDEX IF NOT EXISTS idx_${membershipsTable}_tenant ON ${membershipsTableFull}(tenant_id);
+          CREATE INDEX IF NOT EXISTS idx_${membershipsTable}_user ON ${membershipsTableFull}(user_id);
+          CREATE INDEX IF NOT EXISTS idx_${membershipsTable}_role ON ${membershipsTableFull}(role);
+        `);
+      } catch (error) {
+        console.error('[PostgresTenantStore] Failed to initialize:', error);
+        throw new Error(
+          `Failed to initialize tenants tables: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+
+    async getById(id: string): Promise<Tenant | null> {
+      const result = await getPool().query(`SELECT * FROM ${tenantsTableFull} WHERE id = $1`, [id]);
+      return (result.rows[0] as Tenant) || null;
+    },
+
+    async getByIds(ids: string[]): Promise<Tenant[]> {
+      if (ids.length === 0) return [];
+      const result = await getPool().query(`SELECT * FROM ${tenantsTableFull} WHERE id = ANY($1)`, [ids]);
+      return result.rows as Tenant[];
+    },
+
+    async getByName(name: string): Promise<Tenant | null> {
+      const result = await getPool().query(`SELECT * FROM ${tenantsTableFull} WHERE LOWER(name) = LOWER($1)`, [
+        name,
+      ]);
+      return (result.rows[0] as Tenant) || null;
+    },
+
+    async create(input: CreateTenantInput): Promise<Tenant> {
+      const { name, type, owner_id, metadata = {} } = input;
+
+      const result = await getPool().query(
+        `INSERT INTO ${tenantsTableFull} (name, type, owner_id, metadata)
+         VALUES ($1, $2, $3, $4)
+         RETURNING *`,
+        [name, type, owner_id, JSON.stringify(metadata)]
+      );
+
+      const tenant = result.rows[0] as Tenant;
+
+      // Automatically add owner as a member with 'owner' role
+      await this.addMember({
+        tenant_id: tenant.id,
+        user_id: owner_id,
+        role: 'owner',
+      });
+
+      return tenant;
+    },
+
+    async update(id: string, input: UpdateTenantInput): Promise<Tenant | null> {
+      const { name, metadata } = input;
+      const updates: string[] = [];
+      const values: unknown[] = [];
+      let paramCount = 1;
+
+      if (name !== undefined) {
+        updates.push(`name = $${paramCount++}`);
+        values.push(name);
+      }
+
+      if (metadata !== undefined) {
+        updates.push(`metadata = $${paramCount++}`);
+        values.push(JSON.stringify(metadata));
+      }
+
+      if (updates.length === 0) {
+        return this.getById(id);
+      }
+
+      updates.push(`updated_at = NOW()`);
+      values.push(id);
+
+      const result = await getPool().query(
+        `UPDATE ${tenantsTableFull}
+         SET ${updates.join(', ')}
+         WHERE id = $${paramCount}
+         RETURNING *`,
+        values
+      );
+
+      return (result.rows[0] as Tenant) || null;
+    },
+
+    async delete(id: string): Promise<boolean> {
+      const result = await getPool().query(`DELETE FROM ${tenantsTableFull} WHERE id = $1`, [id]);
+      return (result.rowCount ?? 0) > 0;
+    },
+
+    async search(params: TenantSearchParams): Promise<TenantListResponse> {
+      const { query, type, owner_id, page = 1, limit = 50, sortBy = 'created_at', sortOrder = 'desc' } = params;
+
+      const conditions: string[] = [];
+      const values: unknown[] = [];
+      let paramCount = 1;
+
+      if (query) {
+        conditions.push(`name ILIKE $${paramCount++}`);
+        values.push(`%${query}%`);
+      }
+
+      if (type) {
+        conditions.push(`type = $${paramCount++}`);
+        values.push(type);
+      }
+
+      if (owner_id) {
+        conditions.push(`owner_id = $${paramCount++}`);
+        values.push(owner_id);
+      }
+
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+      // Get total count
+      const countResult = await getPool().query(
+        `SELECT COUNT(*) FROM ${tenantsTableFull} ${whereClause}`,
+        values
+      );
+      const total = parseInt((countResult.rows[0] as { count: string }).count, 10);
+
+      // Get paginated results
+      const offset = (page - 1) * limit;
+      const result = await getPool().query(
+        `SELECT * FROM ${tenantsTableFull}
+         ${whereClause}
+         ORDER BY ${sortBy} ${sortOrder.toUpperCase()}
+         LIMIT $${paramCount++} OFFSET $${paramCount}`,
+        [...values, limit, offset]
+      );
+
+      return {
+        tenants: result.rows as Tenant[],
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      };
+    },
+
+    async getTenantsForUser(userId: string): Promise<TenantWithMembership[]> {
+      const result = await getPool().query(
+        `SELECT t.*, m.role as user_role, m.*
+         FROM ${tenantsTableFull} t
+         JOIN ${membershipsTableFull} m ON t.id = m.tenant_id
+         WHERE m.user_id = $1
+         ORDER BY t.created_at DESC`,
+        [userId]
+      );
+
+      return result.rows.map((row: any) => ({
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        owner_id: row.owner_id,
+        metadata: row.metadata,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        user_role: row.user_role,
+        membership: {
+          id: row.id,
+          tenant_id: row.tenant_id,
+          user_id: row.user_id,
+          role: row.role,
+          joined_at: row.joined_at,
+        },
+      })) as TenantWithMembership[];
+    },
+
+    async getTenantForUser(tenantId: string, userId: string): Promise<TenantWithMembership | null> {
+      const result = await getPool().query(
+        `SELECT t.*, m.role as user_role, m.*
+         FROM ${tenantsTableFull} t
+         JOIN ${membershipsTableFull} m ON t.id = m.tenant_id
+         WHERE t.id = $1 AND m.user_id = $2`,
+        [tenantId, userId]
+      );
+
+      if (!result.rows[0]) return null;
+
+      const row: any = result.rows[0];
+      return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        owner_id: row.owner_id,
+        metadata: row.metadata,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        user_role: row.user_role,
+        membership: {
+          id: row.id,
+          tenant_id: row.tenant_id,
+          user_id: row.user_id,
+          role: row.role,
+          joined_at: row.joined_at,
+        },
+      } as TenantWithMembership;
+    },
+
+    async addMember(input: CreateTenantMembershipInput): Promise<TenantMembership> {
+      const { tenant_id, user_id, role } = input;
+
+      const result = await getPool().query(
+        `INSERT INTO ${membershipsTableFull} (tenant_id, user_id, role)
+         VALUES ($1, $2, $3)
+         ON CONFLICT (tenant_id, user_id) DO UPDATE SET role = $3
+         RETURNING *`,
+        [tenant_id, user_id, role]
+      );
+
+      return result.rows[0] as TenantMembership;
+    },
+
+    async updateMember(
+      tenantId: string,
+      userId: string,
+      input: UpdateTenantMembershipInput
+    ): Promise<TenantMembership | null> {
+      const { role } = input;
+
+      if (!role) {
+        return this.getMembership(tenantId, userId);
+      }
+
+      const result = await getPool().query(
+        `UPDATE ${membershipsTableFull}
+         SET role = $1
+         WHERE tenant_id = $2 AND user_id = $3
+         RETURNING *`,
+        [role, tenantId, userId]
+      );
+
+      return (result.rows[0] as TenantMembership) || null;
+    },
+
+    async removeMember(tenantId: string, userId: string): Promise<boolean> {
+      const result = await getPool().query(
+        `DELETE FROM ${membershipsTableFull}
+         WHERE tenant_id = $1 AND user_id = $2`,
+        [tenantId, userId]
+      );
+      return (result.rowCount ?? 0) > 0;
+    },
+
+    async getMembers(tenantId: string): Promise<TenantMembership[]> {
+      const result = await getPool().query(
+        `SELECT * FROM ${membershipsTableFull}
+         WHERE tenant_id = $1
+         ORDER BY joined_at ASC`,
+        [tenantId]
+      );
+
+      return result.rows as TenantMembership[];
+    },
+
+    async getMembership(tenantId: string, userId: string): Promise<TenantMembership | null> {
+      const result = await getPool().query(
+        `SELECT * FROM ${membershipsTableFull}
+         WHERE tenant_id = $1 AND user_id = $2`,
+        [tenantId, userId]
+      );
+
+      return (result.rows[0] as TenantMembership) || null;
+    },
+
+    async shutdown(): Promise<void> {
+      // PostgreSQL pool is managed externally, nothing to shutdown here
+    },
+  };
+}