@plures/praxis 0.2.0

package/src/cloud/marketplace.ts

@@ -0,0 +1,303 @@
+/**
+ * GitHub Marketplace API Client
+ * 
+ * Client for GitHub Marketplace SaaS integration (preparatory).
+ */
+
+import type { Subscription } from "./billing.js";
+import { SubscriptionTier, SubscriptionStatus, BillingProvider, TIER_LIMITS } from "./billing.js";
+
+/**
+ * GitHub Marketplace plan
+ */
+export interface MarketplacePlan {
+  /**
+   * Plan ID
+   */
+  id: number;
+  
+  /**
+   * Plan name
+   */
+  name: string;
+  
+  /**
+   * Plan description
+   */
+  description: string;
+  
+  /**
+   * Monthly price in cents
+   */
+  monthlyPriceInCents: number;
+  
+  /**
+   * Yearly price in cents
+   */
+  yearlyPriceInCents: number;
+  
+  /**
+   * Price model
+   */
+  priceModel: "FLAT_RATE" | "PER_UNIT";
+  
+  /**
+   * Whether this plan has a free trial
+   */
+  hasFreeTrial: boolean;
+  
+  /**
+   * Unit name (for per-unit pricing)
+   */
+  unitName?: string;
+  
+  /**
+   * Bullets (features list)
+   */
+  bullets: string[];
+}
+
+/**
+ * Marketplace account
+ */
+export interface MarketplaceAccount {
+  /**
+   * Account ID
+   */
+  id: number;
+  
+  /**
+   * Account login
+   */
+  login: string;
+  
+  /**
+   * Account type
+   */
+  type: "User" | "Organization";
+  
+  /**
+   * Plan
+   */
+  plan: MarketplacePlan;
+  
+  /**
+   * Whether account is on free trial
+   */
+  onFreeTrial: boolean;
+  
+  /**
+   * Free trial ends on (if applicable)
+   */
+  freeTrialEndsOn?: string;
+  
+  /**
+   * Next billing date
+   */
+  nextBillingDate?: string;
+}
+
+/**
+ * Marketplace webhook event
+ */
+export interface MarketplaceWebhookEvent {
+  /**
+   * Action type
+   */
+  action: "purchased" | "cancelled" | "changed" | "pending_change" | "pending_change_cancelled";
+  
+  /**
+   * Effective date
+   */
+  effectiveDate?: string;
+  
+  /**
+   * Marketplace purchase
+   */
+  marketplacePurchase: {
+    account: MarketplaceAccount;
+    billingCycle: "monthly" | "yearly";
+    unitCount?: number;
+    onFreeTrial: boolean;
+    freeTrialEndsOn?: string;
+    nextBillingDate?: string;
+  };
+  
+  /**
+   * Previous plan (for changes)
+   */
+  previousMarketplacePurchase?: {
+    account: MarketplaceAccount;
+    billingCycle: "monthly" | "yearly";
+    unitCount?: number;
+  };
+}
+
+/**
+ * Praxis Cloud Marketplace plans configuration
+ */
+export const MARKETPLACE_PLANS = {
+  solo: {
+    name: "Praxis Cloud Solo",
+    description: "For individual developers",
+    monthlyPriceInCents: 500, // $5/month
+    yearlyPriceInCents: 5000, // $50/year (2 months free)
+    features: [
+      "50,000 syncs/month",
+      "1 GB storage",
+      "10 apps/projects",
+      "Standard support",
+    ],
+  },
+  team: {
+    name: "Praxis Cloud Team",
+    description: "For small teams",
+    monthlyPriceInCents: 2000, // $20/month
+    yearlyPriceInCents: 20000, // $200/year (2 months free)
+    features: [
+      "500,000 syncs/month",
+      "10 GB storage",
+      "50 apps/projects",
+      "Up to 10 team members",
+      "Standard support",
+    ],
+  },
+  enterprise: {
+    name: "Praxis Cloud Enterprise",
+    description: "For large teams and organizations",
+    monthlyPriceInCents: 5000, // $50/month
+    yearlyPriceInCents: 50000, // $500/year (2 months free)
+    features: [
+      "5,000,000 syncs/month",
+      "100 GB storage",
+      "1,000 apps/projects",
+      "Unlimited team members",
+      "Priority support",
+      "SLA guarantees",
+    ],
+  },
+};
+
+/**
+ * GitHub Marketplace API client
+ */
+export class GitHubMarketplaceClient {
+  private token: string;
+  
+  constructor(token: string) {
+    this.token = token;
+  }
+  
+  /**
+   * Get accounts for the authenticated user
+   */
+  async getAccounts(): Promise<MarketplaceAccount[]> {
+    try {
+      const response = await fetch(
+        "https://api.github.com/marketplace_listing/accounts",
+        {
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            Accept: "application/vnd.github.v3+json",
+          },
+        }
+      );
+      
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.statusText}`);
+      }
+      
+      return await response.json() as MarketplaceAccount[];
+    } catch (error) {
+      console.error("Failed to get marketplace accounts:", error);
+      return [];
+    }
+  }
+  
+  /**
+   * Get subscription from marketplace account
+   */
+  async getSubscription(accountId: number): Promise<Subscription | null> {
+    const accounts = await this.getAccounts();
+    const account = accounts.find((a) => a.id === accountId);
+    
+    if (!account) {
+      return null;
+    }
+    
+    // Map plan to tier
+    let tier = SubscriptionTier.FREE;
+    if (account.plan.monthlyPriceInCents >= 5000) {
+      tier = SubscriptionTier.ENTERPRISE;
+    } else if (account.plan.monthlyPriceInCents >= 2000) {
+      tier = SubscriptionTier.TEAM;
+    } else if (account.plan.monthlyPriceInCents >= 500) {
+      tier = SubscriptionTier.SOLO;
+    }
+    
+    return {
+      tier,
+      status: SubscriptionStatus.ACTIVE,
+      provider: BillingProvider.MARKETPLACE,
+      marketplacePlanId: account.plan.id,
+      startDate: account.onFreeTrial && account.freeTrialEndsOn
+        ? new Date(account.freeTrialEndsOn).getTime()
+        : Date.now(),
+      periodEnd: account.nextBillingDate
+        ? new Date(account.nextBillingDate).getTime()
+        : undefined,
+      autoRenew: true,
+      limits: TIER_LIMITS[tier],
+    };
+  }
+  
+  /**
+   * Handle marketplace webhook event
+   */
+  handleWebhookEvent(event: MarketplaceWebhookEvent): {
+    userId: number;
+    userLogin: string;
+    subscription: Subscription;
+  } | null {
+    const account = event.marketplacePurchase.account;
+    
+    if (event.action === "cancelled") {
+      // Handle cancellation
+      return null;
+    }
+    
+    // Map plan to tier
+    let tier = SubscriptionTier.FREE;
+    if (account.plan.monthlyPriceInCents >= 5000) {
+      tier = SubscriptionTier.ENTERPRISE;
+    } else if (account.plan.monthlyPriceInCents >= 2000) {
+      tier = SubscriptionTier.TEAM;
+    } else if (account.plan.monthlyPriceInCents >= 500) {
+      tier = SubscriptionTier.SOLO;
+    }
+    
+    return {
+      userId: account.id,
+      userLogin: account.login,
+      subscription: {
+        tier,
+        status: SubscriptionStatus.ACTIVE,
+        provider: BillingProvider.MARKETPLACE,
+        marketplacePlanId: account.plan.id,
+        startDate: Date.now(),
+        periodEnd: event.marketplacePurchase.nextBillingDate
+          ? new Date(event.marketplacePurchase.nextBillingDate).getTime()
+          : undefined,
+        autoRenew: true,
+        limits: TIER_LIMITS[tier],
+      },
+    };
+  }
+}
+
+/**
+ * Create a GitHub Marketplace client
+ */
+export function createMarketplaceClient(token: string): GitHubMarketplaceClient {
+  return new GitHubMarketplaceClient(token);
+}

package/src/cloud/provisioning.ts

@@ -0,0 +1,254 @@
+/**
+ * Auto-Provisioning
+ * 
+ * Automatic tenant/storage provisioning based on GitHub identity.
+ */
+
+import type { GitHubUser } from "./types.js";
+import type { Subscription } from "./billing.js";
+
+/**
+ * Tenant information
+ */
+export interface Tenant {
+  /**
+   * Tenant ID (derived from GitHub user/org)
+   */
+  id: string;
+  
+  /**
+   * GitHub user ID
+   */
+  githubUserId: number;
+  
+  /**
+   * GitHub login (username or org name)
+   */
+  githubLogin: string;
+  
+  /**
+   * Tenant type
+   */
+  type: "user" | "organization";
+  
+  /**
+   * Subscription
+   */
+  subscription: Subscription;
+  
+  /**
+   * Storage namespace
+   */
+  storageNamespace: string;
+  
+  /**
+   * Creation timestamp
+   */
+  createdAt: number;
+  
+  /**
+   * Last accessed timestamp
+   */
+  lastAccessedAt: number;
+}
+
+/**
+ * Generate a storage namespace from GitHub login
+ * 
+ * Namespace format: gh-{login}-{hash}
+ * This ensures uniqueness and follows Azure Blob Storage naming rules.
+ */
+export function generateStorageNamespace(githubLogin: string, userId: number): string {
+  // Sanitize login: lowercase, replace non-alphanumeric with hyphens
+  const sanitized = githubLogin.toLowerCase().replace(/[^a-z0-9]/g, "-");
+  
+  // Create a simple hash from user ID for uniqueness
+  const hash = userId.toString(36).padStart(6, "0");
+  
+  // Combine with prefix
+  return `gh-${sanitized}-${hash}`;
+}
+
+/**
+ * Generate tenant ID from GitHub user
+ */
+export function generateTenantId(githubUser: GitHubUser): string {
+  return `github-${githubUser.id}`;
+}
+
+/**
+ * Create a tenant from GitHub user
+ */
+export function createTenant(
+  githubUser: GitHubUser,
+  subscription: Subscription
+): Tenant {
+  const tenantId = generateTenantId(githubUser);
+  const storageNamespace = generateStorageNamespace(
+    githubUser.login,
+    githubUser.id
+  );
+  
+  return {
+    id: tenantId,
+    githubUserId: githubUser.id,
+    githubLogin: githubUser.login,
+    type: "user", // Could be "organization" if checking org membership
+    subscription,
+    storageNamespace,
+    createdAt: Date.now(),
+    lastAccessedAt: Date.now(),
+  };
+}
+
+/**
+ * Validate storage namespace
+ * 
+ * Ensures namespace follows Azure Blob Storage naming rules:
+ * - 3-63 characters
+ * - lowercase letters, numbers, and hyphens only
+ * - must start with letter or number
+ * - no consecutive hyphens
+ */
+export function validateStorageNamespace(namespace: string): {
+  valid: boolean;
+  error?: string;
+} {
+  if (namespace.length < 3 || namespace.length > 63) {
+    return {
+      valid: false,
+      error: "Namespace must be 3-63 characters",
+    };
+  }
+  
+  if (!/^[a-z0-9]/.test(namespace)) {
+    return {
+      valid: false,
+      error: "Namespace must start with a letter or number",
+    };
+  }
+  
+  if (!/^[a-z0-9-]+$/.test(namespace)) {
+    return {
+      valid: false,
+      error: "Namespace can only contain lowercase letters, numbers, and hyphens",
+    };
+  }
+  
+  if (/--/.test(namespace)) {
+    return {
+      valid: false,
+      error: "Namespace cannot contain consecutive hyphens",
+    };
+  }
+  
+  return { valid: true };
+}
+
+/**
+ * Get storage container name for an app
+ */
+export function getAppStorageContainer(
+  tenantNamespace: string,
+  appId: string
+): string {
+  // Sanitize app ID
+  const sanitizedAppId = appId.toLowerCase().replace(/[^a-z0-9]/g, "-");
+  return `${tenantNamespace}-${sanitizedAppId}`;
+}
+
+/**
+ * Provisioning result
+ */
+export interface ProvisioningResult {
+  /**
+   * Whether provisioning was successful
+   */
+  success: boolean;
+  
+  /**
+   * Tenant (if successful)
+   */
+  tenant?: Tenant;
+  
+  /**
+   * Error message (if failed)
+   */
+  error?: string;
+}
+
+/**
+ * Provision a new tenant
+ * 
+ * This would typically:
+ * 1. Create storage containers
+ * 2. Set up access policies
+ * 3. Initialize tenant metadata
+ * 4. Register with billing system
+ */
+export async function provisionTenant(
+  githubUser: GitHubUser,
+  subscription: Subscription
+): Promise<ProvisioningResult> {
+  try {
+    const tenant = createTenant(githubUser, subscription);
+    
+    // Validate storage namespace
+    const validation = validateStorageNamespace(tenant.storageNamespace);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: validation.error,
+      };
+    }
+    
+    // TODO: In production, this would:
+    // 1. Create Azure Blob Storage container
+    // 2. Set up access policies
+    // 3. Store tenant metadata in database
+    // 4. Send welcome email
+    // 5. Log provisioning event
+    
+    console.log(`Provisioned tenant: ${tenant.id}`);
+    console.log(`Storage namespace: ${tenant.storageNamespace}`);
+    
+    return {
+      success: true,
+      tenant,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * Get or create tenant
+ * 
+ * Checks if tenant exists, creates if not.
+ */
+export async function getOrCreateTenant(
+  githubUser: GitHubUser,
+  subscription: Subscription,
+  tenantLookup: (id: string) => Promise<Tenant | null>
+): Promise<Tenant> {
+  const tenantId = generateTenantId(githubUser);
+  
+  // Try to get existing tenant
+  const existing = await tenantLookup(tenantId);
+  if (existing) {
+    // Update last accessed time
+    existing.lastAccessedAt = Date.now();
+    return existing;
+  }
+  
+  // Provision new tenant
+  const result = await provisionTenant(githubUser, subscription);
+  if (!result.success || !result.tenant) {
+    throw new Error(`Failed to provision tenant: ${result.error}`);
+  }
+  
+  return result.tenant;
+}