@auxiora/cloud 1.0.0 → 1.3.0

package/tests/billing.test.ts

@@ -1,126 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { TenantManager } from '../src/tenant.js';
-import { BillingManager } from '../src/billing.js';
-import type { CloudConfig, StripeClient } from '../src/types.js';
-
-function makeConfig(baseDataDir: string): CloudConfig {
-  return {
-    enabled: true,
-    baseDataDir,
-    jwtSecret: 'test-secret-32-chars-long-enough!',
-    domain: 'test.auxiora.cloud',
-  };
-}
-
-function createMockStripe(): StripeClient {
-  return {
-    createCustomer: vi.fn().mockResolvedValue({ id: 'cus_test123' }),
-    createSubscription: vi.fn().mockResolvedValue({ id: 'sub_test123', status: 'active' }),
-    cancelSubscription: vi.fn().mockResolvedValue(undefined),
-    getInvoices: vi.fn().mockResolvedValue([
-      { id: 'inv_1', amount: 1900, status: 'paid', created: '2025-01-01T00:00:00Z' },
-    ]),
-    createPaymentIntent: vi.fn().mockResolvedValue({ clientSecret: 'pi_secret' }),
-  };
-}
-
-describe('BillingManager', () => {
-  let tenantManager: TenantManager;
-  let billing: BillingManager;
-  let mockStripe: StripeClient;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cloud-billing-'));
-    tenantManager = new TenantManager({ config: makeConfig(tmpDir) });
-    mockStripe = createMockStripe();
-    billing = new BillingManager({ tenantManager, stripe: mockStripe });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('createCustomer', () => {
-    it('should create a Stripe customer', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const customerId = await billing.createCustomer(tenant.id);
-      expect(customerId).toBe('cus_test123');
-      expect(mockStripe.createCustomer).toHaveBeenCalledWith('alice@test.com', 'Alice');
-    });
-
-    it('should throw if Stripe not configured', async () => {
-      const billingNoStripe = new BillingManager({ tenantManager });
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      await expect(billingNoStripe.createCustomer(tenant.id)).rejects.toThrow('Stripe not configured');
-    });
-  });
-
-  describe('createSubscription', () => {
-    it('should create a subscription', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      // Manually set stripeCustomerId
-      (tenant as any).stripeCustomerId = 'cus_test123';
-
-      const result = await billing.createSubscription(tenant.id, 'pro');
-      expect(result.subscriptionId).toBe('sub_test123');
-      expect(result.status).toBe('active');
-    });
-
-    it('should throw without customer ID', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      await expect(billing.createSubscription(tenant.id, 'pro')).rejects.toThrow('No Stripe customer ID');
-    });
-  });
-
-  describe('getBillingInfo', () => {
-    it('should return billing info', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'pro');
-      const info = await billing.getBillingInfo(tenant.id);
-      expect(info.tenantId).toBe(tenant.id);
-      expect(info.plan).toBe('pro');
-    });
-  });
-
-  describe('getInvoices', () => {
-    it('should return invoices from Stripe', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      (tenant as any).stripeCustomerId = 'cus_test123';
-
-      const invoices = await billing.getInvoices(tenant.id);
-      expect(invoices).toHaveLength(1);
-      expect(invoices[0].id).toBe('inv_1');
-    });
-
-    it('should return empty for tenant without customer', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const invoices = await billing.getInvoices(tenant.id);
-      expect(invoices).toHaveLength(0);
-    });
-  });
-
-  describe('handleWebhookEvent', () => {
-    it('should downgrade on subscription deleted', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'pro');
-      (tenant as any).stripeCustomerId = 'cus_alice';
-
-      await billing.handleWebhookEvent('customer.subscription.deleted', { customer: 'cus_alice' });
-
-      const updated = await tenantManager.get(tenant.id);
-      expect(updated.plan).toBe('free');
-    });
-
-    it('should suspend on payment failed', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'pro');
-      (tenant as any).stripeCustomerId = 'cus_alice';
-
-      await billing.handleWebhookEvent('invoice.payment_failed', { customer: 'cus_alice' });
-
-      const updated = await tenantManager.get(tenant.id);
-      expect(updated.status).toBe('suspended');
-    });
-  });
-});

package/tests/isolation.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { TenantManager } from '../src/tenant.js';
-import { TenantIsolation } from '../src/isolation.js';
-import { TenantNotFoundError, TenantSuspendedError } from '../src/types.js';
-import type { CloudConfig } from '../src/types.js';
-
-function makeConfig(baseDataDir: string): CloudConfig {
-  return {
-    enabled: true,
-    baseDataDir,
-    jwtSecret: 'test-secret-32-chars-long-enough!',
-    domain: 'test.auxiora.cloud',
-  };
-}
-
-describe('TenantIsolation', () => {
-  let tenantManager: TenantManager;
-  let isolation: TenantIsolation;
-  let tmpDir: string;
-  let config: CloudConfig;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cloud-isolation-'));
-    config = makeConfig(tmpDir);
-    tenantManager = new TenantManager({ config });
-    isolation = new TenantIsolation({ tenantManager, config });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('extractTenant', () => {
-    it('should extract tenant from JWT payload with tenantId', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const context = await isolation.extractTenant({ tenantId: tenant.id });
-      expect(context.tenantId).toBe(tenant.id);
-      expect(context.tenant.email).toBe('alice@test.com');
-    });
-
-    it('should extract tenant from JWT payload with sub', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const context = await isolation.extractTenant({ sub: tenant.id });
-      expect(context.tenantId).toBe(tenant.id);
-    });
-
-    it('should throw for missing tenant ID', async () => {
-      await expect(isolation.extractTenant({})).rejects.toThrow(TenantNotFoundError);
-    });
-
-    it('should throw for suspended tenant', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      await tenantManager.suspend(tenant.id, 'overdue');
-      await expect(isolation.extractTenant({ tenantId: tenant.id })).rejects.toThrow(TenantSuspendedError);
-    });
-
-    it('should throw for deleted tenant', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      await tenantManager.delete(tenant.id);
-      await expect(isolation.extractTenant({ tenantId: tenant.id })).rejects.toThrow(TenantNotFoundError);
-    });
-  });
-
-  describe('scopePath', () => {
-    it('should resolve paths within tenant dir', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const scoped = isolation.scopePath(tenant, 'config/settings.json');
-      expect(scoped).toContain(tenant.id);
-      expect(scoped).toContain('config/settings.json');
-    });
-
-    it('should block path traversal', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      expect(() => isolation.scopePath(tenant, '../../etc/passwd')).toThrow('Path traversal');
-    });
-  });
-
-  describe('validateAccess', () => {
-    it('should allow access to own resources', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const context = await isolation.extractTenant({ tenantId: tenant.id });
-      expect(isolation.validateAccess(context, tenant.id)).toBe(true);
-    });
-
-    it('should deny access to other tenant resources', async () => {
-      const alice = await tenantManager.create('alice@test.com', 'Alice');
-      const bob = await tenantManager.create('bob@test.com', 'Bob');
-      const context = await isolation.extractTenant({ tenantId: alice.id });
-      expect(isolation.validateAccess(context, bob.id)).toBe(false);
-    });
-  });
-});

package/tests/plans.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getPlanDefinition, getPlanQuotas, getAllPlans, isValidPlan } from '../src/plans.js';
-
-describe('Plans', () => {
-  describe('getPlanDefinition', () => {
-    it('should return free plan', () => {
-      const plan = getPlanDefinition('free');
-      expect(plan.name).toBe('Free');
-      expect(plan.priceMonthly).toBe(0);
-    });
-
-    it('should return pro plan', () => {
-      const plan = getPlanDefinition('pro');
-      expect(plan.name).toBe('Pro');
-      expect(plan.priceMonthly).toBe(19);
-    });
-
-    it('should return team plan', () => {
-      const plan = getPlanDefinition('team');
-      expect(plan.name).toBe('Team');
-      expect(plan.priceMonthly).toBe(49);
-    });
-
-    it('should return enterprise plan', () => {
-      const plan = getPlanDefinition('enterprise');
-      expect(plan.name).toBe('Enterprise');
-      expect(plan.quotas.maxMessages).toBe(-1);
-    });
-  });
-
-  describe('getPlanQuotas', () => {
-    it('should return quotas for free plan', () => {
-      const quotas = getPlanQuotas('free');
-      expect(quotas.maxMessages).toBe(100);
-      expect(quotas.maxSessions).toBe(3);
-    });
-
-    it('should return unlimited for enterprise', () => {
-      const quotas = getPlanQuotas('enterprise');
-      expect(quotas.maxMessages).toBe(-1);
-      expect(quotas.maxSessions).toBe(-1);
-    });
-  });
-
-  describe('getAllPlans', () => {
-    it('should return all four plans', () => {
-      const plans = getAllPlans();
-      expect(plans).toHaveLength(4);
-      const names = plans.map(p => p.plan);
-      expect(names).toContain('free');
-      expect(names).toContain('pro');
-      expect(names).toContain('team');
-      expect(names).toContain('enterprise');
-    });
-  });
-
-  describe('isValidPlan', () => {
-    it('should return true for valid plans', () => {
-      expect(isValidPlan('free')).toBe(true);
-      expect(isValidPlan('pro')).toBe(true);
-      expect(isValidPlan('team')).toBe(true);
-      expect(isValidPlan('enterprise')).toBe(true);
-    });
-
-    it('should return false for invalid plans', () => {
-      expect(isValidPlan('platinum')).toBe(false);
-      expect(isValidPlan('')).toBe(false);
-    });
-  });
-});

package/tests/quotas.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { TenantManager } from '../src/tenant.js';
-import { QuotaEnforcer } from '../src/quotas.js';
-import { QuotaExceededError } from '../src/types.js';
-import type { CloudConfig } from '../src/types.js';
-
-function makeConfig(baseDataDir: string): CloudConfig {
-  return {
-    enabled: true,
-    baseDataDir,
-    jwtSecret: 'test-secret-32-chars-long-enough!',
-    domain: 'test.auxiora.cloud',
-  };
-}
-
-describe('QuotaEnforcer', () => {
-  let tenantManager: TenantManager;
-  let enforcer: QuotaEnforcer;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cloud-quota-'));
-    tenantManager = new TenantManager({ config: makeConfig(tmpDir) });
-    enforcer = new QuotaEnforcer({ tenantManager });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('check', () => {
-    it('should pass when under quota', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'free');
-      await expect(enforcer.check(tenant.id, 'maxMessages')).resolves.toBeUndefined();
-    });
-
-    it('should throw QuotaExceededError when over limit', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'free');
-      // Free plan: 100 messages
-      for (let i = 0; i < 100; i++) {
-        enforcer.record(tenant.id, 'maxMessages');
-      }
-      await expect(enforcer.check(tenant.id, 'maxMessages')).rejects.toThrow(QuotaExceededError);
-    });
-
-    it('should not throw for enterprise (unlimited)', async () => {
-      const tenant = await tenantManager.create('corp@test.com', 'Corp', 'enterprise');
-      for (let i = 0; i < 10000; i++) {
-        enforcer.record(tenant.id, 'maxMessages');
-      }
-      await expect(enforcer.check(tenant.id, 'maxMessages')).resolves.toBeUndefined();
-    });
-  });
-
-  describe('record', () => {
-    it('should track usage', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      enforcer.record(tenant.id, 'maxMessages');
-      enforcer.record(tenant.id, 'maxMessages');
-      expect(enforcer.getUsage(tenant.id, 'maxMessages')).toBe(2);
-    });
-
-    it('should return usage record', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      const record = enforcer.record(tenant.id, 'maxSessions', 3);
-      expect(record.tenantId).toBe(tenant.id);
-      expect(record.metric).toBe('maxSessions');
-      expect(record.value).toBe(3);
-    });
-  });
-
-  describe('getAllUsage', () => {
-    it('should return all metrics', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      enforcer.record(tenant.id, 'maxMessages', 10);
-      enforcer.record(tenant.id, 'maxSessions', 2);
-      const usage = enforcer.getAllUsage(tenant.id);
-      expect(usage.maxMessages).toBe(10);
-      expect(usage.maxSessions).toBe(2);
-    });
-
-    it('should return empty for unknown tenant', () => {
-      const usage = enforcer.getAllUsage('nonexistent');
-      expect(usage).toEqual({});
-    });
-  });
-
-  describe('resetUsage', () => {
-    it('should reset all usage for a tenant', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice');
-      enforcer.record(tenant.id, 'maxMessages', 50);
-      enforcer.resetUsage(tenant.id);
-      expect(enforcer.getUsage(tenant.id, 'maxMessages')).toBe(0);
-    });
-  });
-
-  describe('getUsagePercentage', () => {
-    it('should calculate percentage', async () => {
-      const tenant = await tenantManager.create('alice@test.com', 'Alice', 'free');
-      enforcer.record(tenant.id, 'maxMessages', 50);
-      const pct = await enforcer.getUsagePercentage(tenant.id, 'maxMessages');
-      expect(pct).toBe(50);
-    });
-
-    it('should return 0 for enterprise (unlimited)', async () => {
-      const tenant = await tenantManager.create('corp@test.com', 'Corp', 'enterprise');
-      enforcer.record(tenant.id, 'maxMessages', 999);
-      const pct = await enforcer.getUsagePercentage(tenant.id, 'maxMessages');
-      expect(pct).toBe(0);
-    });
-  });
-});

package/tests/tenant.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { TenantManager } from '../src/tenant.js';
-import { TenantNotFoundError } from '../src/types.js';
-import type { CloudConfig } from '../src/types.js';
-
-function makeConfig(baseDataDir: string): CloudConfig {
-  return {
-    enabled: true,
-    baseDataDir,
-    jwtSecret: 'test-secret-32-chars-long-enough!',
-    domain: 'test.auxiora.cloud',
-  };
-}
-
-describe('TenantManager', () => {
-  let manager: TenantManager;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'cloud-tenant-'));
-    manager = new TenantManager({ config: makeConfig(tmpDir) });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  describe('create', () => {
-    it('should create a tenant with defaults', async () => {
-      const tenant = await manager.create('alice@test.com', 'Alice');
-      expect(tenant.id).toMatch(/^tenant-/);
-      expect(tenant.email).toBe('alice@test.com');
-      expect(tenant.name).toBe('Alice');
-      expect(tenant.plan).toBe('free');
-      expect(tenant.status).toBe('active');
-      expect(tenant.dataDir).toContain(tenant.id);
-    });
-
-    it('should create a tenant with a specific plan', async () => {
-      const tenant = await manager.create('bob@test.com', 'Bob', 'pro');
-      expect(tenant.plan).toBe('pro');
-    });
-
-    it('should persist tenant to disk', async () => {
-      const tenant = await manager.create('charlie@test.com', 'Charlie');
-      const tenantFile = path.join(tenant.dataDir, 'tenant.json');
-      const content = await fs.readFile(tenantFile, 'utf-8');
-      const persisted = JSON.parse(content);
-      expect(persisted.email).toBe('charlie@test.com');
-    });
-  });
-
-  describe('get', () => {
-    it('should return an existing tenant', async () => {
-      const created = await manager.create('alice@test.com', 'Alice');
-      const found = await manager.get(created.id);
-      expect(found.email).toBe('alice@test.com');
-    });
-
-    it('should throw TenantNotFoundError for unknown id', async () => {
-      await expect(manager.get('nonexistent')).rejects.toThrow(TenantNotFoundError);
-    });
-  });
-
-  describe('getByEmail', () => {
-    it('should find a tenant by email', async () => {
-      await manager.create('alice@test.com', 'Alice');
-      const found = await manager.getByEmail('alice@test.com');
-      expect(found).not.toBeNull();
-      expect(found!.name).toBe('Alice');
-    });
-
-    it('should return null for unknown email', async () => {
-      const found = await manager.getByEmail('nobody@test.com');
-      expect(found).toBeNull();
-    });
-  });
-
-  describe('update', () => {
-    it('should update tenant fields', async () => {
-      const tenant = await manager.create('alice@test.com', 'Alice');
-      const updated = await manager.update(tenant.id, { name: 'Alice Smith', plan: 'pro' });
-      expect(updated.name).toBe('Alice Smith');
-      expect(updated.plan).toBe('pro');
-    });
-  });
-
-  describe('suspend / reactivate', () => {
-    it('should suspend and reactivate a tenant', async () => {
-      const tenant = await manager.create('alice@test.com', 'Alice');
-
-      const suspended = await manager.suspend(tenant.id, 'Payment failed');
-      expect(suspended.status).toBe('suspended');
-      expect(suspended.suspendReason).toBe('Payment failed');
-
-      const reactivated = await manager.reactivate(tenant.id);
-      expect(reactivated.status).toBe('active');
-      expect(reactivated.suspendedAt).toBeUndefined();
-    });
-  });
-
-  describe('delete', () => {
-    it('should mark tenant as deleted', async () => {
-      const tenant = await manager.create('alice@test.com', 'Alice');
-      const result = await manager.delete(tenant.id);
-      expect(result).toBe(true);
-
-      const list = await manager.list();
-      expect(list).toHaveLength(0);
-    });
-
-    it('should return false for unknown tenant', async () => {
-      const result = await manager.delete('nonexistent');
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('list', () => {
-    it('should list active tenants', async () => {
-      await manager.create('alice@test.com', 'Alice');
-      await manager.create('bob@test.com', 'Bob');
-      const list = await manager.list();
-      expect(list).toHaveLength(2);
-    });
-
-    it('should exclude deleted tenants', async () => {
-      const a = await manager.create('alice@test.com', 'Alice');
-      await manager.create('bob@test.com', 'Bob');
-      await manager.delete(a.id);
-      const list = await manager.list();
-      expect(list).toHaveLength(1);
-    });
-  });
-
-  describe('loadFromDisk', () => {
-    it('should reload tenants from disk', async () => {
-      const tenant = await manager.create('alice@test.com', 'Alice');
-
-      // Create new manager and load
-      const manager2 = new TenantManager({ config: makeConfig(tmpDir) });
-      await manager2.loadFromDisk();
-      const found = await manager2.get(tenant.id);
-      expect(found.email).toBe('alice@test.com');
-    });
-  });
-});

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "references": [
-    { "path": "../core" },
-    { "path": "../logger" },
-    { "path": "../audit" }
-  ]
-}