@startup-api/cloudflare 0.0.1

package/src/storage/AccountDO.ts

@@ -0,0 +1,370 @@
+import { DurableObject } from 'cloudflare:workers';
+import { initPlans } from '../billing/plansConfig';
+import { Plan } from '../billing/Plan';
+import { MockPaymentEngine } from '../billing/PaymentEngine';
+import { StartupAPIEnv } from '../StartupAPIEnv';
+import { AccountInfoSchema, MemberSchema } from '../schemas/account';
+import { BillingStateSchema } from '../schemas/billing';
+import type { AccountInfo, Member } from '../schemas/account';
+import type { BillingState } from '../schemas/billing';
+
+/**
+ * A Durable Object representing an Account (Tenant).
+ * This class handles account-specific data, settings, and memberships.
+ */
+export class AccountDO extends DurableObject {
+  static ROLE_USER = 0;
+  static ROLE_ADMIN = 1;
+
+  sql: SqlStorage;
+  paymentEngine: MockPaymentEngine;
+
+  constructor(state: DurableObjectState, env: StartupAPIEnv) {
+    super(state, env);
+    this.sql = state.storage.sql;
+    this.paymentEngine = new MockPaymentEngine();
+
+    // Initialize plans if not already done
+    if (!Plan.isInitialized()) {
+      initPlans();
+    }
+
+    // Initialize database schema
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS account_info (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        name TEXT,
+        plan TEXT,
+        billing TEXT,
+        personal INTEGER
+      );
+
+      CREATE TABLE IF NOT EXISTS members (
+        user_id TEXT PRIMARY KEY,
+        role INTEGER,
+        joined_at INTEGER
+      );
+    `);
+
+    // Ensure the single row exists
+    this.sql.exec('INSERT OR IGNORE INTO account_info (id, plan) VALUES (1, "free")');
+  }
+
+  async getImage(key: string): Promise<{ value: ArrayBuffer; mime_type: string } | null> {
+    const r2Key = `account/${this.ctx.id.toString()}/${key}`;
+    const object = await this.env.IMAGE_STORAGE.get(r2Key);
+    if (!object) return null;
+    return {
+      value: await object.arrayBuffer(),
+      mime_type: object.httpMetadata?.contentType || 'image/jpeg',
+    };
+  }
+
+  async storeImage(key: string, value: ArrayBuffer, mime_type: string): Promise<{ success: boolean }> {
+    const r2Key = `account/${this.ctx.id.toString()}/${key}`;
+    await this.env.IMAGE_STORAGE.put(r2Key, value, {
+      httpMetadata: { contentType: mime_type },
+    });
+    return { success: true };
+  }
+
+  async deleteImage(key: string): Promise<{ success: boolean }> {
+    const r2Key = `account/${this.ctx.id.toString()}/${key}`;
+    await this.env.IMAGE_STORAGE.delete(r2Key);
+    return { success: true };
+  }
+
+  async getInfo(): Promise<AccountInfo> {
+    try {
+      const result = this.sql.exec('SELECT * FROM account_info WHERE id = 1');
+      const row = result.next().value as any;
+      if (!row) return {};
+
+      return AccountInfoSchema.parse({
+        name: row.name,
+        plan: row.plan,
+        personal: row.personal === 1,
+        billing: row.billing ? JSON.parse(row.billing) : undefined,
+      });
+    } catch (_e) {
+      return {};
+    }
+  }
+
+  async updateInfo(data: Record<string, any>): Promise<{ success: boolean }> {
+    try {
+      const validatedData = AccountInfoSchema.partial().parse(data);
+      const updates: string[] = [];
+      const values: any[] = [];
+
+      if ('name' in validatedData) {
+        updates.push('name = ?');
+        values.push(typeof validatedData.name === 'string' ? validatedData.name.substring(0, 50) : validatedData.name);
+      }
+      if ('plan' in validatedData) {
+        updates.push('plan = ?');
+        values.push(validatedData.plan);
+      }
+      if ('personal' in validatedData) {
+        updates.push('personal = ?');
+        values.push(validatedData.personal ? 1 : 0);
+      }
+
+      if (updates.length > 0) {
+        this.ctx.storage.transactionSync(() => {
+          this.sql.exec(`UPDATE account_info SET ${updates.join(', ')} WHERE id = 1`, ...values);
+
+          // If plan is updated manually (e.g. via Admin API), update billing state too
+          if ('plan' in data) {
+            const currentState = this.getBillingState();
+            if (currentState.plan_slug !== data.plan) {
+              const newState: BillingState = {
+                ...currentState,
+                plan_slug: data.plan,
+              };
+              this.sql.exec('UPDATE account_info SET billing = ? WHERE id = 1', JSON.stringify(newState));
+            }
+          }
+        });
+      }
+      return { success: true };
+    } catch (e) {
+      throw new Error(e instanceof Error ? e.message : String(e));
+    }
+  }
+
+  async getMembers(): Promise<Member[]> {
+    const result = Array.from(this.sql.exec('SELECT user_id, role, joined_at FROM members'));
+    const membersWithNames = await Promise.all(
+      result.map(async (m: any) => {
+        try {
+          const userStub = this.env.USER.get(this.env.USER.idFromString(m.user_id));
+          const profile = await userStub.getProfile();
+          const image = await userStub.getImage('avatar');
+
+          let picture = profile.picture || null;
+          if (image) {
+            picture = `/users/api/users/${m.user_id}/avatar`;
+          } else {
+            picture = null;
+          }
+
+          return MemberSchema.parse({
+            ...m,
+            name: profile.name || 'Unknown User',
+            picture: picture,
+          });
+        } catch (_e) {
+          return MemberSchema.parse({ ...m, name: 'Unknown User', picture: null });
+        }
+      }),
+    );
+    return membersWithNames;
+  }
+
+  async addMember(user_id: string, role: number): Promise<{ success: boolean }> {
+    const now = Date.now();
+
+    // Update Account DO
+    this.sql.exec('INSERT OR REPLACE INTO members (user_id, role, joined_at) VALUES (?, ?, ?)', user_id, role, now);
+
+    // Update SystemDO index
+    await this.syncMemberCount();
+
+    // Sync with User DO
+    try {
+      const userStub = this.env.USER.get(this.env.USER.idFromString(user_id));
+      await userStub.addMembership(this.ctx.id.toString(), role, false);
+    } catch (_e) {
+      console.error('Failed to sync membership to UserDO', _e);
+    }
+
+    return { success: true };
+  }
+
+  async updateMemberRole(userId: string, role: number): Promise<{ success: boolean }> {
+    this.sql.exec('UPDATE members SET role = ? WHERE user_id = ?', role, userId);
+
+    // Sync with User DO
+    try {
+      const userStub = this.env.USER.get(this.env.USER.idFromString(userId));
+      await userStub.addMembership(this.ctx.id.toString(), role, false);
+    } catch (_e) {
+      console.error('Failed to sync membership role to UserDO', _e);
+    }
+
+    return { success: true };
+  }
+
+  async removeMember(userId: string): Promise<{ success: boolean }> {
+    this.sql.exec('DELETE FROM members WHERE user_id = ?', userId);
+
+    // Update SystemDO index
+    await this.syncMemberCount();
+
+    // Sync with User DO
+    try {
+      const userStub = this.env.USER.get(this.env.USER.idFromString(userId));
+      await userStub.deleteMembership(this.ctx.id.toString());
+    } catch (_e) {
+      console.error('Failed to sync membership removal to UserDO', _e);
+    }
+
+    return { success: true };
+  }
+
+  private async syncMemberCount(): Promise<void> {
+    try {
+      const result = this.sql.exec('SELECT COUNT(*) as count FROM members');
+      const row = result.next().value as any;
+      const count = row ? row.count : 0;
+
+      const systemStub = this.env.SYSTEM.get(this.env.SYSTEM.idFromName('global'));
+      await systemStub.updateMemberCount(this.ctx.id.toString(), count);
+    } catch (_e) {
+      console.error('Failed to update member count in SystemDO', _e);
+    }
+  }
+
+  async delete(): Promise<{ success: boolean }> {
+    // Get all members to notify their UserDOs
+    const members = Array.from(this.sql.exec('SELECT user_id FROM members'));
+    for (const member of members as any[]) {
+      try {
+        const userStub = this.env.USER.get(this.env.USER.idFromString(member.user_id));
+        await userStub.deleteMembership(this.ctx.id.toString());
+      } catch (_e) {
+        console.error(`Failed to notify UserDO ${member.user_id} of account deletion`, _e);
+      }
+    }
+
+    // Delete all account images from R2
+    const prefix = `account/${this.ctx.id.toString()}/`;
+    const listed = await this.env.IMAGE_STORAGE.list({ prefix });
+    const keys = listed.objects.map((o) => o.key);
+    if (keys.length > 0) {
+      await this.env.IMAGE_STORAGE.delete(keys);
+    }
+
+    // Wipe all Durable Object storage
+    await this.ctx.storage.deleteAll();
+
+    return { success: true };
+  }
+
+  // Billing Implementation
+
+  private getBillingState(): BillingState {
+    try {
+      const result = this.sql.exec('SELECT billing FROM account_info WHERE id = 1');
+      const row = result.next().value as any;
+      if (row && row.billing) {
+        return BillingStateSchema.parse(JSON.parse(row.billing));
+      }
+    } catch (_e) {
+      // ignore
+    }
+    return {
+      plan_slug: 'free',
+      status: 'active',
+    };
+  }
+
+  private setBillingState(state: BillingState): void {
+    this.ctx.storage.transactionSync(() => {
+      this.sql.exec('UPDATE account_info SET billing = ?, plan = ? WHERE id = 1', JSON.stringify(state), state.plan_slug);
+    });
+  }
+
+  async getBillingInfo(): Promise<{ state: BillingState; plan_details: any }> {
+    const state = this.getBillingState();
+    const plan = Plan.get(state.plan_slug);
+
+    // Create a serializable version of the plan
+    const planDetails = plan
+      ? {
+          slug: plan.slug,
+          name: plan.name,
+          capabilities: plan.capabilities,
+          downgrade_to_slug: plan.downgrade_to_slug,
+          grace_period: plan.grace_period,
+          schedules: plan.schedules.map((s) => ({
+            charge_amount: s.charge_amount,
+            charge_period: s.charge_period,
+            is_default: s.is_default,
+          })),
+        }
+      : null;
+
+    return {
+      state,
+      plan_details: planDetails,
+    };
+  }
+
+  async subscribe(plan_slug: string, schedule_idx: number = 0): Promise<{ success: boolean; state: BillingState }> {
+    const plan = Plan.get(plan_slug);
+
+    if (!plan) {
+      throw new Error('Plan not found');
+    }
+
+    const currentState = this.getBillingState();
+
+    // Call hook if changing plans (simplification)
+    if (currentState.plan_slug !== plan_slug) {
+      if (currentState.plan_slug) {
+        const oldPlan = Plan.get(currentState.plan_slug);
+        if (oldPlan?.account_deactivate_hook) {
+          await oldPlan.account_deactivate_hook(this.ctx.id.toString());
+        }
+      }
+      if (plan.account_activate_hook) {
+        await plan.account_activate_hook(this.ctx.id.toString());
+      }
+    }
+
+    // Setup recurring payment
+    try {
+      await this.paymentEngine.setupRecurring(this.ctx.id.toString(), plan_slug, schedule_idx);
+    } catch (e) {
+      throw new Error(`Payment setup failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+
+    const newState: BillingState = {
+      ...currentState,
+      plan_slug,
+      status: 'active',
+      schedule_idx,
+      next_billing_date: Date.now() + (plan.schedules[schedule_idx]?.charge_period || 30) * 24 * 60 * 60 * 1000,
+    };
+
+    this.setBillingState(newState);
+
+    return { success: true, state: newState };
+  }
+
+  async cancelSubscription(): Promise<{ success: boolean; state: BillingState }> {
+    const currentState = this.getBillingState();
+    const currentPlan = Plan.get(currentState.plan_slug);
+
+    if (!currentPlan) {
+      throw new Error('No active plan');
+    }
+
+    await this.paymentEngine.cancelRecurring(this.ctx.id.toString());
+
+    // Downgrade logic (immediate or scheduled - simplification: scheduled if downgrade_to_slug exists)
+    // For this prototype, we'll mark it as canceled and set the next plan if applicable.
+
+    const newState: BillingState = {
+      ...currentState,
+      status: 'canceled',
+      next_plan_slug: currentPlan.downgrade_to_slug,
+    };
+
+    this.setBillingState(newState);
+
+    return { success: true, state: newState };
+  }
+}

package/src/storage/CredentialDO.ts

@@ -0,0 +1,82 @@
+import { DurableObject } from 'cloudflare:workers';
+import { StartupAPIEnv } from '../StartupAPIEnv';
+import { OAuthCredentialSchema } from '../schemas/credential';
+import type { OAuthCredential, OAuthCredentialOutput } from '../schemas/credential';
+
+/**
+ * A Durable Object representing all OAuth credentials for a specific provider.
+ * Each instance is identified by the provider name (e.g., "google", "twitch").
+ */
+export class CredentialDO extends DurableObject {
+  sql: SqlStorage;
+
+  constructor(state: DurableObjectState, env: StartupAPIEnv) {
+    super(state, env);
+    this.sql = state.storage.sql;
+
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS credentials (
+        subject_id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        access_token TEXT,
+        refresh_token TEXT,
+        expires_at INTEGER,
+        scope TEXT,
+        profile_data TEXT,
+        created_at INTEGER,
+        updated_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS idx_user_id ON credentials(user_id);
+    `);
+  }
+
+  async get(subjectId: string): Promise<any | null> {
+    const result = this.sql.exec('SELECT * FROM credentials WHERE subject_id = ?', subjectId);
+    const row = result.next().value as any;
+    if (!row) return null;
+
+    row.profile_data = JSON.parse(row.profile_data);
+    return row;
+  }
+
+  async list(userId: string): Promise<any[]> {
+    const result = this.sql.exec('SELECT * FROM credentials WHERE user_id = ?', userId);
+    const credentials = [];
+    for (const row of result) {
+      (row as any).profile_data = JSON.parse((row as any).profile_data);
+      credentials.push(row);
+    }
+    return credentials;
+  }
+
+  async put(data: OAuthCredential): Promise<{ success: boolean }> {
+    console.log('[auth] Parsing Cred', data);
+
+    const validatedData: OAuthCredentialOutput = OAuthCredentialSchema.parse(data);
+
+    console.log('[auth] Validated Cred', validatedData);
+
+    const now = Date.now();
+
+    this.sql.exec(
+      `INSERT OR REPLACE INTO credentials 
+      (subject_id, user_id, access_token, refresh_token, expires_at, scope, profile_data, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      validatedData.subject_id,
+      validatedData.user_id,
+      validatedData.access_token,
+      validatedData.refresh_token,
+      validatedData.expires_at,
+      validatedData.scope,
+      JSON.stringify(validatedData.profile_data),
+      validatedData.created_at || now,
+      now,
+    );
+    return { success: true };
+  }
+
+  async delete(subjectId: string): Promise<{ success: boolean }> {
+    this.sql.exec('DELETE FROM credentials WHERE subject_id = ?', subjectId);
+    return { success: true };
+  }
+}

package/src/storage/SystemDO.ts

@@ -0,0 +1,264 @@
+import { DurableObject } from 'cloudflare:workers';
+import { StartupAPIEnv } from '../StartupAPIEnv';
+import { SystemUserSchema } from '../schemas/user';
+import { SystemAccountSchema } from '../schemas/account';
+import type { SystemUser } from '../schemas/user';
+import type { SystemAccount } from '../schemas/account';
+
+export class SystemDO extends DurableObject {
+  sql: SqlStorage;
+
+  constructor(state: DurableObjectState, env: StartupAPIEnv) {
+    super(state, env);
+    this.sql = state.storage.sql;
+
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS users (
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        email TEXT,
+        provider TEXT,
+        created_at INTEGER
+      );
+
+      CREATE TABLE IF NOT EXISTS accounts (
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        status TEXT,
+        plan TEXT,
+        member_count INTEGER DEFAULT 0,
+        created_at INTEGER
+      );
+    `);
+  }
+
+  async listUsers(query?: string): Promise<any[]> {
+    let sql = 'SELECT * FROM users';
+    const args: any[] = [];
+
+    if (query) {
+      sql += ' WHERE name LIKE ? OR email LIKE ?';
+      args.push(`%${query}%`, `%${query}%`);
+    }
+
+    sql += ' ORDER BY created_at DESC LIMIT 50';
+
+    const result = this.sql.exec(sql, ...args);
+    const users = Array.from(result).map((u: any) => {
+      const adminIds = (this.env.ADMIN_IDS || '').split(',').map((id) => id.trim());
+      const isAdmin =
+        adminIds.includes(u.id) ||
+        (this.env.ENVIRONMENT === 'test' &&
+          adminIds.some((id) => {
+            try {
+              return u.id === this.env.USER.idFromName(id).toString();
+            } catch (_e) {
+              return false;
+            }
+          }));
+
+      return {
+        ...u,
+        is_admin: isAdmin,
+      };
+    });
+    return users;
+  }
+
+  async getUserMemberships(userId: string): Promise<any[]> {
+    const userStub = this.env.USER.get(this.env.USER.idFromString(userId));
+    return await userStub.getMemberships();
+  }
+
+  async getUser(userId: string): Promise<any> {
+    try {
+      const userStub = this.env.USER.get(this.env.USER.idFromString(userId));
+      const profile = await userStub.getProfile();
+      return profile;
+    } catch (e) {
+      throw new Error(e instanceof Error ? e.message : String(e));
+    }
+  }
+
+  async registerUser(data: SystemUser): Promise<{ success: boolean }> {
+    const validatedData = SystemUserSchema.parse(data);
+    const now = Date.now();
+
+    this.sql.exec(
+      'INSERT OR REPLACE INTO users (id, name, email, provider, created_at) VALUES (?, ?, ?, ?, ?)',
+      validatedData.id,
+      validatedData.name,
+      validatedData.email || null,
+      validatedData.provider || null,
+      now,
+    );
+
+    return { success: true };
+  }
+
+  async deleteUser(userId: string): Promise<{ success: boolean }> {
+    // Delete from index
+    this.sql.exec('DELETE FROM users WHERE id = ?', userId);
+
+    // Call UserDO to delete its data
+    try {
+      const stub = this.env.USER.get(this.env.USER.idFromString(userId));
+      await stub.delete();
+    } catch (e) {
+      console.error('Failed to clear UserDO data', e);
+    }
+
+    return { success: true };
+  }
+
+  async updateUser(userId: string, data: Partial<SystemUser>): Promise<{ success: boolean }> {
+    const validatedData = SystemUserSchema.partial().parse(data);
+    // Update UserDO
+    try {
+      const userStub = this.env.USER.get(this.env.USER.idFromString(userId));
+      await userStub.updateProfile(validatedData);
+    } catch (e) {
+      console.error('Failed to update UserDO', e);
+    }
+
+    // Update Index
+    if (validatedData.name || validatedData.email) {
+      const updates: string[] = [];
+      const args: any[] = [];
+      if (validatedData.name !== undefined) {
+        updates.push('name = ?');
+        args.push(validatedData.name);
+      }
+      if (validatedData.email !== undefined) {
+        updates.push('email = ?');
+        args.push(validatedData.email);
+      }
+
+      if (updates.length > 0) {
+        args.push(userId);
+        this.sql.exec(`UPDATE users SET ${updates.join(', ')} WHERE id = ?`, ...args);
+      }
+    }
+
+    return { success: true };
+  }
+
+  async listAccounts(query?: string): Promise<any[]> {
+    let sql = 'SELECT * FROM accounts';
+    const args: any[] = [];
+
+    if (query) {
+      sql += ' WHERE name LIKE ?';
+      args.push(`%${query}%`);
+    }
+
+    sql += ' ORDER BY created_at DESC LIMIT 50';
+
+    const result = this.sql.exec(sql, ...args);
+    return Array.from(result);
+  }
+
+  async getAccount(accountId: string): Promise<any> {
+    try {
+      const stub = this.env.ACCOUNT.get(this.env.ACCOUNT.idFromString(accountId));
+      const info = await stub.getInfo();
+      const billing = await stub.getBillingInfo();
+
+      return { ...info, billing };
+    } catch (e) {
+      throw new Error(e instanceof Error ? e.message : String(e));
+    }
+  }
+
+  async registerAccount(data: SystemAccount): Promise<{ success: boolean; id: string }> {
+    const validatedData = SystemAccountSchema.parse(data);
+    let accountIdStr = validatedData.id;
+    const accountName = validatedData.name;
+
+    if (!accountIdStr) {
+      const id = this.env.ACCOUNT.newUniqueId();
+      accountIdStr = id.toString();
+
+      // Initialize AccountDO
+      const stub = this.env.ACCOUNT.get(id);
+      await stub.updateInfo({
+        name: accountName,
+      });
+
+      // If owner provided, add them as ADMIN
+      if (validatedData.ownerId) {
+        await stub.addMember(validatedData.ownerId, 1);
+      }
+    }
+
+    const now = Date.now();
+
+    this.sql.exec(
+      'INSERT OR REPLACE INTO accounts (id, name, status, plan, member_count, created_at) VALUES (?, ?, ?, ?, ?, ?)',
+      accountIdStr,
+      accountName,
+      validatedData.status || 'active',
+      validatedData.plan || 'free',
+      validatedData.ownerId ? 1 : 0,
+      now,
+    );
+
+    return { success: true, id: accountIdStr };
+  }
+
+  async deleteAccount(accountId: string): Promise<{ success: boolean }> {
+    // Delete from index
+    this.sql.exec('DELETE FROM accounts WHERE id = ?', accountId);
+
+    // Call AccountDO to delete its data
+    try {
+      const stub = this.env.ACCOUNT.get(this.env.ACCOUNT.idFromString(accountId));
+      await stub.delete();
+    } catch (e) {
+      console.error('Failed to clear AccountDO data', e);
+    }
+
+    return { success: true };
+  }
+
+  async updateMemberCount(accountId: string, count: number): Promise<void> {
+    this.sql.exec('UPDATE accounts SET member_count = ? WHERE id = ?', count, accountId);
+  }
+
+  async updateAccount(accountId: string, data: Partial<SystemAccount>): Promise<{ success: boolean }> {
+    const validatedData = SystemAccountSchema.partial().parse(data);
+
+    // Update AccountDO
+    try {
+      const stub = this.env.ACCOUNT.get(this.env.ACCOUNT.idFromString(accountId));
+      await stub.updateInfo(validatedData);
+    } catch (e) {
+      console.error('Failed to update AccountDO', e);
+    }
+
+    // Update Index
+    const updates: string[] = [];
+    const args: any[] = [];
+
+    if (validatedData.name !== undefined) {
+      updates.push('name = ?');
+      args.push(validatedData.name);
+    }
+    if (validatedData.status !== undefined) {
+      updates.push('status = ?');
+      args.push(validatedData.status);
+    }
+    // Plan update usually via billing, but if forced:
+    if (validatedData.plan !== undefined) {
+      updates.push('plan = ?');
+      args.push(validatedData.plan);
+    }
+
+    if (updates.length > 0) {
+      args.push(accountId);
+      this.sql.exec(`UPDATE accounts SET ${updates.join(', ')} WHERE id = ?`, ...args);
+    }
+
+    return { success: true };
+  }
+}