@plures/praxis 0.2.0

package/src/cloud/relay/endpoints.ts

@@ -0,0 +1,307 @@
+/**
+ * Azure Functions Relay Endpoints
+ * 
+ * HTTP-triggered Azure Functions for Praxis Cloud Relay.
+ */
+
+import type {
+  CRDTSyncMessage,
+  UsageMetrics,
+  HealthCheckResponse,
+} from "../types.js";
+
+/**
+ * Azure Function context (simplified interface)
+ */
+export interface AzureContext {
+  log: (message: string) => void;
+  done: (err?: Error, result?: unknown) => void;
+}
+
+/**
+ * Azure HTTP request
+ */
+export interface AzureHttpRequest {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  body?: unknown;
+}
+
+/**
+ * Azure HTTP response
+ */
+export interface AzureHttpResponse {
+  status: number;
+  headers?: Record<string, string>;
+  body?: unknown;
+}
+
+/**
+ * In-memory storage for demo (replace with Azure Storage in production)
+ */
+const storage = {
+  syncs: new Map<string, CRDTSyncMessage[]>(),
+  usage: new Map<string, UsageMetrics>(),
+};
+
+/**
+ * Health check endpoint
+ * GET /health
+ */
+export async function healthEndpoint(
+  context: AzureContext,
+  _req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Health check requested");
+
+  const response: HealthCheckResponse = {
+    status: "healthy",
+    timestamp: Date.now(),
+    version: "0.1.0",
+    services: {
+      relay: true,
+      eventGrid: true,
+      storage: true,
+      auth: true,
+    },
+  };
+
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: response,
+  };
+}
+
+/**
+ * CRDT sync endpoint
+ * POST /sync
+ */
+export async function syncEndpoint(
+  context: AzureContext,
+  req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Sync request received");
+
+  // Validate request
+  if (req.method !== "POST") {
+    return {
+      status: 405,
+      body: { error: "Method not allowed" },
+    };
+  }
+
+  const message = req.body as CRDTSyncMessage;
+
+  if (!message || !message.appId) {
+    return {
+      status: 400,
+      body: { error: "Invalid sync message" },
+    };
+  }
+
+  // Store sync message
+  const appSyncs = storage.syncs.get(message.appId) || [];
+  appSyncs.push(message);
+  storage.syncs.set(message.appId, appSyncs);
+
+  // Update usage metrics
+  const usage = storage.usage.get(message.appId) || {
+    appId: message.appId,
+    syncCount: 0,
+    eventCount: 0,
+    factCount: 0,
+    storageBytes: 0,
+    periodStart: Date.now(),
+    periodEnd: Date.now(),
+  };
+
+  usage.syncCount++;
+  usage.eventCount += message.events?.length || 0;
+  usage.factCount += message.facts?.length || 0;
+  usage.storageBytes += JSON.stringify(message).length;
+  usage.periodEnd = Date.now();
+
+  storage.usage.set(message.appId, usage);
+
+  context.log(`Synced for app ${message.appId}: ${usage.syncCount} total syncs`);
+
+  // Return updated vector clock
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: {
+      success: true,
+      clock: message.clock,
+      timestamp: Date.now(),
+    },
+  };
+}
+
+/**
+ * Usage metrics endpoint
+ * GET /usage?appId=<appId>
+ */
+export async function usageEndpoint(
+  context: AzureContext,
+  req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Usage metrics requested");
+
+  const appId = req.query.appId;
+
+  if (!appId) {
+    return {
+      status: 400,
+      body: { error: "appId query parameter is required" },
+    };
+  }
+
+  const usage = storage.usage.get(appId);
+
+  if (!usage) {
+    return {
+      status: 404,
+      body: { error: "No usage data found for this app" },
+    };
+  }
+
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: usage,
+  };
+}
+
+/**
+ * Stats endpoint for aggregated metrics
+ * GET /stats?appId=<appId>
+ */
+export async function statsEndpoint(
+  context: AzureContext,
+  req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Stats requested");
+
+  const appId = req.query.appId;
+
+  if (!appId) {
+    return {
+      status: 400,
+      body: { error: "appId query parameter is required" },
+    };
+  }
+
+  const usage = storage.usage.get(appId);
+  const syncs = storage.syncs.get(appId) || [];
+
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: {
+      appId,
+      totalSyncs: syncs.length,
+      usage: usage || null,
+      lastSync: syncs.length > 0 ? syncs[syncs.length - 1].timestamp : null,
+    },
+  };
+}
+
+/**
+ * Event forwarding endpoint
+ * POST /events
+ */
+export async function eventsEndpoint(
+  context: AzureContext,
+  req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Event forwarding requested");
+
+  if (req.method !== "POST") {
+    return {
+      status: 405,
+      body: { error: "Method not allowed" },
+    };
+  }
+
+  const { appId, events } = req.body as { appId: string; events: unknown[] };
+
+  if (!appId || !events) {
+    return {
+      status: 400,
+      body: { error: "Invalid event forwarding request" },
+    };
+  }
+
+  context.log(`Forwarding ${events.length} events for app ${appId}`);
+
+  // In production, publish to Azure Event Grid / Service Bus
+  // For now, just acknowledge receipt
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: {
+      success: true,
+      forwarded: events.length,
+      timestamp: Date.now(),
+    },
+  };
+}
+
+/**
+ * Schema registry endpoint
+ * GET /schema?appId=<appId>
+ * POST /schema (to register a schema)
+ */
+export async function schemaEndpoint(
+  context: AzureContext,
+  req: AzureHttpRequest
+): Promise<AzureHttpResponse> {
+  context.log("Schema registry requested");
+
+  if (req.method === "POST") {
+    const { appId, schema } = req.body as { appId: string; schema: unknown };
+
+    if (!appId || !schema) {
+      return {
+        status: 400,
+        body: { error: "Invalid schema registration request" },
+      };
+    }
+
+    context.log(`Schema registered for app ${appId}`);
+
+    return {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+      body: {
+        success: true,
+        schemaId: `${appId}-${Date.now()}`,
+        timestamp: Date.now(),
+      },
+    };
+  }
+
+  // GET request
+  const appId = req.query.appId;
+
+  if (!appId) {
+    return {
+      status: 400,
+      body: { error: "appId query parameter is required" },
+    };
+  }
+
+  // Return placeholder schema
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: {
+      appId,
+      schema: null,
+      message: "Schema not found",
+    },
+  };
+}

package/src/cloud/relay/health/function.json

@@ -0,0 +1,17 @@
+{
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": ["get"],
+      "route": "health"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "res"
+    }
+  ]
+}

package/src/cloud/relay/health/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Azure Function: Health Check
+ */
+
+import { healthEndpoint } from "../endpoints.js";
+
+export default async function (context: any, req: any) {
+  const response = await healthEndpoint(context, req);
+  context.res = response;
+}

package/src/cloud/relay/host.json

@@ -0,0 +1,15 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "maxTelemetryItemsPerSecond": 20
+      }
+    }
+  },
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  }
+}

package/src/cloud/relay/local.settings.json

@@ -0,0 +1,8 @@
+{
+  "IsEncrypted": false,
+  "Values": {
+    "AzureWebJobsStorage": "",
+    "FUNCTIONS_WORKER_RUNTIME": "node",
+    "NODE_ENV": "production"
+  }
+}

package/src/cloud/relay/stats/function.json

@@ -0,0 +1,17 @@
+{
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": ["get"],
+      "route": "stats"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "res"
+    }
+  ]
+}

package/src/cloud/relay/stats/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Azure Function: Stats
+ */
+
+import { statsEndpoint } from "../endpoints.js";
+
+export default async function (context: any, req: any) {
+  const response = await statsEndpoint(context, req);
+  context.res = response;
+}

package/src/cloud/relay/sync/function.json

@@ -0,0 +1,17 @@
+{
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": ["post"],
+      "route": "sync"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "res"
+    }
+  ]
+}

package/src/cloud/relay/sync/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Azure Function: CRDT Sync
+ */
+
+import { syncEndpoint } from "../endpoints.js";
+
+export default async function (context: any, req: any) {
+  const response = await syncEndpoint(context, req);
+  context.res = response;
+}

package/src/cloud/relay/usage/function.json

@@ -0,0 +1,17 @@
+{
+  "bindings": [
+    {
+      "authLevel": "anonymous",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": ["get"],
+      "route": "usage"
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "res"
+    }
+  ]
+}

package/src/cloud/relay/usage/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Azure Function: Usage Metrics
+ */
+
+import { usageEndpoint } from "../endpoints.js";
+
+export default async function (context: any, req: any) {
+  const response = await usageEndpoint(context, req);
+  context.res = response;
+}

package/src/cloud/sponsors.ts

@@ -0,0 +1,213 @@
+/**
+ * GitHub Sponsors API Client
+ * 
+ * Client for checking GitHub Sponsors subscription status.
+ */
+
+import type { Subscription } from "./billing.js";
+import { createSponsorSubscription, createFreeSubscription } from "./billing.js";
+
+/**
+ * GitHub Sponsors tier information
+ */
+export interface SponsorTier {
+  /**
+   * Tier ID
+   */
+  id: string;
+  
+  /**
+   * Tier name
+   */
+  name: string;
+  
+  /**
+   * Monthly price in cents
+   */
+  monthlyPriceInCents: number;
+  
+  /**
+   * Tier description
+   */
+  description?: string;
+  
+  /**
+   * Whether this is a one-time sponsorship
+   */
+  isOneTime: boolean;
+}
+
+/**
+ * Sponsorship information
+ */
+export interface Sponsorship {
+  /**
+   * Sponsor login
+   */
+  sponsorLogin: string;
+  
+  /**
+   * Sponsor ID
+   */
+  sponsorId: number;
+  
+  /**
+   * Tier information
+   */
+  tier: SponsorTier;
+  
+  /**
+   * Creation date
+   */
+  createdAt: string;
+  
+  /**
+   * Whether sponsorship is active
+   */
+  isActive: boolean;
+}
+
+/**
+ * GitHub Sponsors API client
+ */
+export class GitHubSponsorsClient {
+  private token: string;
+  private accountLogin: string;
+  
+  constructor(token: string, accountLogin: string) {
+    this.token = token;
+    this.accountLogin = accountLogin;
+  }
+  
+  /**
+   * Get current user's sponsorship of the Praxis account
+   */
+  async getSponsorship(userLogin: string): Promise<Sponsorship | null> {
+    try {
+      const query = `
+        query($accountLogin: String!, $userLogin: String!) {
+          user(login: $userLogin) {
+            sponsorshipForViewerAsSponsor(activeOnly: true) {
+              tier {
+                id
+                name
+                monthlyPriceInCents
+                description
+                isOneTime
+              }
+              createdAt
+              isActive
+            }
+            sponsorshipsAsSponsor(first: 100, activeOnly: true) {
+              nodes {
+                sponsorable {
+                  ... on User {
+                    login
+                  }
+                  ... on Organization {
+                    login
+                  }
+                }
+                tier {
+                  id
+                  name
+                  monthlyPriceInCents
+                  description
+                  isOneTime
+                }
+                createdAt
+                isActive
+              }
+            }
+          }
+        }
+      `;
+      
+      const response = await fetch("https://api.github.com/graphql", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            accountLogin: this.accountLogin,
+            userLogin,
+          },
+        }),
+      });
+      
+      if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.statusText}`);
+      }
+      
+      const data = await response.json() as any;
+      
+      if (data.errors) {
+        throw new Error(`GraphQL error: ${JSON.stringify(data.errors)}`);
+      }
+      
+      // Check if user sponsors the Praxis account
+      const sponsorships = data.data?.user?.sponsorshipsAsSponsor?.nodes || [];
+      const praxisSponsorship = sponsorships.find(
+        (s: any) => s.sponsorable?.login === this.accountLogin
+      );
+      
+      if (!praxisSponsorship) {
+        return null;
+      }
+      
+      return {
+        sponsorLogin: userLogin,
+        sponsorId: data.data.user.id,
+        tier: {
+          id: praxisSponsorship.tier.id,
+          name: praxisSponsorship.tier.name,
+          monthlyPriceInCents: praxisSponsorship.tier.monthlyPriceInCents,
+          description: praxisSponsorship.tier.description,
+          isOneTime: praxisSponsorship.tier.isOneTime,
+        },
+        createdAt: praxisSponsorship.createdAt,
+        isActive: praxisSponsorship.isActive,
+      };
+    } catch (error) {
+      console.error("Failed to get sponsorship:", error);
+      return null;
+    }
+  }
+  
+  /**
+   * Get subscription from sponsorship
+   */
+  async getSubscription(userLogin: string): Promise<Subscription> {
+    const sponsorship = await this.getSponsorship(userLogin);
+    
+    if (!sponsorship || !sponsorship.isActive) {
+      return createFreeSubscription();
+    }
+    
+    return createSponsorSubscription(
+      sponsorship.tier.name,
+      sponsorship.tier.monthlyPriceInCents
+    );
+  }
+  
+  /**
+   * Check if user is a sponsor
+   */
+  async isSponsor(userLogin: string): Promise<boolean> {
+    const sponsorship = await this.getSponsorship(userLogin);
+    return sponsorship !== null && sponsorship.isActive;
+  }
+}
+
+/**
+ * Create a GitHub Sponsors client
+ */
+export function createSponsorsClient(
+  token: string,
+  accountLogin: string = "plures"
+): GitHubSponsorsClient {
+  return new GitHubSponsorsClient(token, accountLogin);
+}