beddel 0.2.3 → 1.0.0

package/src/tenant/interfaces.ts

@@ -1,231 +0,0 @@
-/**
- * Agnostic Multi-Tenant Interfaces
- * Provider-independent abstractions for multi-tenant operations
- */
-
-// =============================================================================
-// Provider Types
-// =============================================================================
-
-/**
- * Built-in provider type
- */
-export type BuiltInProviderType = 'memory';
-
-/**
- * Provider type accepts built-in or any registered external type
- */
-export type ProviderType = BuiltInProviderType | string;
-
-// =============================================================================
-// Provider-Specific Configurations
-// =============================================================================
-
-/**
- * Firebase-specific provider configuration
- */
-export interface FirebaseProviderConfig {
-  projectId: string;
-  databaseURL: string;
-  storageBucket: string;
-}
-
-/**
- * In-memory provider configuration (for testing)
- */
-export interface MemoryProviderConfig {
-  persistToDisk?: boolean;
-}
-
-// =============================================================================
-// Agnostic Tenant Configuration
-// =============================================================================
-
-/**
- * Provider-agnostic tenant configuration
- */
-export interface TenantConfig {
-  tenantId: string;
-  securityProfile: 'ultra-secure' | 'tenant-isolated';
-  dataRetentionDays: number;
-  lgpdEnabled: boolean;
-  gdprEnabled: boolean;
-  provider: ProviderType;
-  providerConfig: FirebaseProviderConfig | MemoryProviderConfig;
-}
-
-// =============================================================================
-// Core Interfaces
-// =============================================================================
-
-/**
- * Abstract provider interface for tenant management
- * Implements Strategy pattern for swappable backends
- */
-export interface ITenantProvider {
-  /**
-   * Initialize a new tenant with the given configuration
-   * @throws TenantAlreadyExistsError if tenant already exists
-   * @throws ValidationError if configuration is invalid
-   */
-  initialize(config: TenantConfig): Promise<ITenantApp>;
-
-  /**
-   * Get an existing tenant app by ID
-   * @throws NotFoundError if tenant does not exist
-   */
-  get(tenantId: string): ITenantApp;
-
-  /**
-   * Remove a tenant and release all associated resources
-   * @throws NotFoundError if tenant does not exist
-   */
-  remove(tenantId: string): Promise<void>;
-
-  /**
-   * List all active tenant IDs
-   */
-  list(): string[];
-
-  /**
-   * The type of this provider
-   */
-  readonly type: ProviderType;
-}
-
-/**
- * Abstract tenant app representing an isolated tenant instance
- */
-export interface ITenantApp {
-  /**
-   * Unique identifier for this tenant
-   */
-  readonly tenantId: string;
-
-  /**
-   * Get the database interface for this tenant
-   */
-  getDatabase(): ITenantDatabase;
-
-  /**
-   * Destroy this tenant app and release resources
-   */
-  destroy(): Promise<void>;
-}
-
-/**
- * Abstract database interface for tenant data operations
- */
-export interface ITenantDatabase {
-  /**
-   * Get a collection by name
-   */
-  collection(name: string): ITenantCollection;
-}
-
-/**
- * Abstract collection interface for document operations
- */
-export interface ITenantCollection {
-  /**
-   * Get a document reference by ID
-   */
-  doc(id: string): ITenantDocument;
-
-  /**
-   * Add a new document with auto-generated ID
-   * @returns The generated document ID
-   */
-  add(data: Record<string, unknown>): Promise<string>;
-
-  /**
-   * Get all documents in this collection
-   */
-  get(): Promise<Array<{ id: string; data: Record<string, unknown> }>>;
-}
-
-/**
- * Abstract document interface for CRUD operations
- */
-export interface ITenantDocument {
-  /**
-   * Get the document data
-   * @returns Document data or null if not found
-   */
-  get(): Promise<Record<string, unknown> | null>;
-
-  /**
-   * Set the document data (creates or overwrites)
-   */
-  set(data: Record<string, unknown>): Promise<void>;
-
-  /**
-   * Update specific fields in the document
-   * @throws NotFoundError if document does not exist
-   */
-  update(data: Record<string, unknown>): Promise<void>;
-
-  /**
-   * Delete the document
-   */
-  delete(): Promise<void>;
-}
-
-// =============================================================================
-// Error Types
-// =============================================================================
-
-/**
- * Base error for tenant operations
- */
-export class TenantError extends Error {
-  constructor(message: string, public code?: string) {
-    super(message);
-    this.name = 'TenantError';
-    Object.setPrototypeOf(this, TenantError.prototype);
-  }
-}
-
-/**
- * Thrown when configuration validation fails
- */
-export class ValidationError extends TenantError {
-  constructor(message: string) {
-    super(message, 'VALIDATION_ERROR');
-    this.name = 'ValidationError';
-    Object.setPrototypeOf(this, ValidationError.prototype);
-  }
-}
-
-/**
- * Thrown when a requested resource is not found
- */
-export class NotFoundError extends TenantError {
-  constructor(message: string) {
-    super(message, 'NOT_FOUND');
-    this.name = 'NotFoundError';
-    Object.setPrototypeOf(this, NotFoundError.prototype);
-  }
-}
-
-/**
- * Thrown when an operation is not supported by the provider
- */
-export class NotSupportedError extends TenantError {
-  constructor(message: string) {
-    super(message, 'NOT_SUPPORTED');
-    this.name = 'NotSupportedError';
-    Object.setPrototypeOf(this, NotSupportedError.prototype);
-  }
-}
-
-/**
- * Thrown when attempting to create a tenant that already exists
- */
-export class TenantAlreadyExistsError extends TenantError {
-  constructor(tenantId: string) {
-    super(`Tenant '${tenantId}' already exists`, 'TENANT_EXISTS');
-    this.name = 'TenantAlreadyExistsError';
-    Object.setPrototypeOf(this, TenantAlreadyExistsError.prototype);
-  }
-}

package/src/tenant/providerFactory.ts

@@ -1,75 +0,0 @@
-/**
- * Provider Factory
- * Factory function for creating tenant providers based on configuration
- * Uses ProviderRegistry for dynamic provider registration
- */
-
-import {
-  ProviderType,
-  ITenantProvider,
-  BuiltInProviderType,
-} from './interfaces';
-import { ProviderRegistry } from './providerRegistry';
-import { InMemoryTenantProvider } from './providers/InMemoryTenantProvider';
-
-/**
- * Built-in provider types
- */
-const BUILTIN_PROVIDERS: readonly BuiltInProviderType[] = ['memory'] as const;
-
-// Register built-in provider on module load
-ProviderRegistry.register('memory', () => new InMemoryTenantProvider());
-
-/**
- * Check if a value is a valid built-in ProviderType
- */
-export function isBuiltInProviderType(type: unknown): type is BuiltInProviderType {
-  return typeof type === 'string' && BUILTIN_PROVIDERS.includes(type as BuiltInProviderType);
-}
-
-/**
- * Check if a value is a valid ProviderType (built-in or registered)
- */
-export function isValidProviderType(type: unknown): type is ProviderType {
-  if (typeof type !== 'string') {
-    return false;
-  }
-  return isBuiltInProviderType(type) || ProviderRegistry.isRegistered(type);
-}
-
-/**
- * Create a tenant provider instance based on the specified type
- * 
- * @param type - The provider type to create (built-in or registered)
- * @returns An instance of ITenantProvider for the specified type
- * @throws ValidationError if the provider type is not registered
- * 
- * @example
- * ```typescript
- * // Create an in-memory provider for testing (built-in)
- * const memoryProvider = createProvider('memory');
- * 
- * // Create a Firebase provider (must be registered by application first)
- * // In your app: ProviderRegistry.register('firebase', () => new FirebaseTenantProvider());
- * const firebaseProvider = createProvider('firebase');
- * ```
- */
-export function createProvider(type: ProviderType): ITenantProvider {
-  return ProviderRegistry.create(type);
-}
-
-/**
- * Get the list of supported provider types (built-in + registered)
- * @returns Array of supported provider type strings
- */
-export function getSupportedProviders(): string[] {
-  return ProviderRegistry.getRegisteredTypes();
-}
-
-/**
- * Get the list of built-in provider types
- * @returns Array of built-in provider type strings
- */
-export function getBuiltInProviders(): readonly BuiltInProviderType[] {
-  return BUILTIN_PROVIDERS;
-}

package/src/tenant/providerRegistry.ts

@@ -1,86 +0,0 @@
-/**
- * Provider Registry
- * Dynamic registration system for external tenant providers
- * Allows applications to register custom providers at runtime
- */
-
-import { ITenantProvider, ValidationError } from './interfaces';
-
-type ProviderFactory = () => ITenantProvider;
-
-/**
- * Registry for tenant providers
- * Applications register their providers here before using TenantManager
- */
-class ProviderRegistryClass {
-  private providers: Map<string, ProviderFactory> = new Map();
-
-  /**
-   * Register a provider factory
-   * @param type - Unique provider type identifier
-   * @param factory - Factory function that creates the provider instance
-   * @throws ValidationError if type is already registered
-   */
-  register(type: string, factory: ProviderFactory): void {
-    if (!type || typeof type !== 'string') {
-      throw new ValidationError('Provider type must be a non-empty string');
-    }
-    if (typeof factory !== 'function') {
-      throw new ValidationError('Provider factory must be a function');
-    }
-    if (this.providers.has(type)) {
-      throw new ValidationError(`Provider type '${type}' is already registered`);
-    }
-    this.providers.set(type, factory);
-  }
-
-  /**
-   * Unregister a provider
-   * @param type - Provider type to remove
-   */
-  unregister(type: string): void {
-    this.providers.delete(type);
-  }
-
-  /**
-   * Create a provider instance
-   * @param type - Provider type to create
-   * @throws ValidationError if provider type is not registered
-   */
-  create(type: string): ITenantProvider {
-    const factory = this.providers.get(type);
-    if (!factory) {
-      const registered = this.getRegisteredTypes();
-      const available = registered.length > 0 
-        ? `Available types: ${registered.join(', ')}`
-        : 'No providers registered';
-      throw new ValidationError(
-        `Unknown provider type: '${type}'. ${available}`
-      );
-    }
-    return factory();
-  }
-
-  /**
-   * Check if a provider type is registered
-   */
-  isRegistered(type: string): boolean {
-    return this.providers.has(type);
-  }
-
-  /**
-   * Get all registered provider types
-   */
-  getRegisteredTypes(): string[] {
-    return Array.from(this.providers.keys());
-  }
-
-  /**
-   * Clear all registered providers (useful for testing)
-   */
-  clear(): void {
-    this.providers.clear();
-  }
-}
-
-export const ProviderRegistry = new ProviderRegistryClass();

package/src/tenant/providers/InMemoryTenantProvider.ts

@@ -1,168 +0,0 @@
-/**
- * In-Memory Tenant Provider
- * Implements ITenantProvider for testing without external dependencies
- */
-
-import {
-  ITenantProvider,
-  ITenantApp,
-  ITenantDatabase,
-  ITenantCollection,
-  ITenantDocument,
-  TenantConfig,
-  ProviderType,
-  NotFoundError,
-  TenantAlreadyExistsError,
-} from '../interfaces';
-
-// =============================================================================
-// In-Memory Document Implementation
-// =============================================================================
-
-class InMemoryDocument implements ITenantDocument {
-  constructor(
-    private storage: Map<string, Record<string, unknown>>,
-    private docId: string
-  ) {}
-
-  async get(): Promise<Record<string, unknown> | null> {
-    return this.storage.get(this.docId) ?? null;
-  }
-
-  async set(data: Record<string, unknown>): Promise<void> {
-    this.storage.set(this.docId, { ...data });
-  }
-
-  async update(data: Record<string, unknown>): Promise<void> {
-    const existing = this.storage.get(this.docId);
-    if (!existing) {
-      throw new NotFoundError(`Document '${this.docId}' not found`);
-    }
-    this.storage.set(this.docId, { ...existing, ...data });
-  }
-
-  async delete(): Promise<void> {
-    this.storage.delete(this.docId);
-  }
-}
-
-
-// =============================================================================
-// In-Memory Collection Implementation
-// =============================================================================
-
-class InMemoryCollection implements ITenantCollection {
-  private documents: Map<string, Record<string, unknown>> = new Map();
-  private autoIdCounter = 0;
-
-  constructor(private collectionName: string) {}
-
-  doc(id: string): ITenantDocument {
-    return new InMemoryDocument(this.documents, id);
-  }
-
-  async add(data: Record<string, unknown>): Promise<string> {
-    const id = `${this.collectionName}_${++this.autoIdCounter}_${Date.now()}`;
-    this.documents.set(id, { ...data });
-    return id;
-  }
-
-  async get(): Promise<Array<{ id: string; data: Record<string, unknown> }>> {
-    const results: Array<{ id: string; data: Record<string, unknown> }> = [];
-    for (const [id, data] of this.documents) {
-      results.push({ id, data: { ...data } });
-    }
-    return results;
-  }
-}
-
-// =============================================================================
-// In-Memory Database Implementation
-// =============================================================================
-
-class InMemoryDatabase implements ITenantDatabase {
-  private collections: Map<string, InMemoryCollection> = new Map();
-
-  collection(name: string): ITenantCollection {
-    let coll = this.collections.get(name);
-    if (!coll) {
-      coll = new InMemoryCollection(name);
-      this.collections.set(name, coll);
-    }
-    return coll;
-  }
-}
-
-
-// =============================================================================
-// In-Memory Tenant App Implementation
-// =============================================================================
-
-class InMemoryTenantApp implements ITenantApp {
-  private database: InMemoryDatabase;
-  private destroyed = false;
-
-  constructor(
-    public readonly tenantId: string,
-    public readonly config: TenantConfig
-  ) {
-    this.database = new InMemoryDatabase();
-  }
-
-  getDatabase(): ITenantDatabase {
-    if (this.destroyed) {
-      throw new NotFoundError(`Tenant '${this.tenantId}' has been destroyed`);
-    }
-    return this.database;
-  }
-
-  async destroy(): Promise<void> {
-    this.destroyed = true;
-    // Clear internal references to allow garbage collection
-    this.database = null as unknown as InMemoryDatabase;
-  }
-}
-
-// =============================================================================
-// In-Memory Tenant Provider Implementation
-// =============================================================================
-
-/**
- * In-memory implementation of ITenantProvider
- * Useful for testing without external dependencies
- */
-export class InMemoryTenantProvider implements ITenantProvider {
-  public readonly type: ProviderType = 'memory';
-  private tenants: Map<string, InMemoryTenantApp> = new Map();
-
-  async initialize(config: TenantConfig): Promise<ITenantApp> {
-    if (this.tenants.has(config.tenantId)) {
-      throw new TenantAlreadyExistsError(config.tenantId);
-    }
-
-    const app = new InMemoryTenantApp(config.tenantId, config);
-    this.tenants.set(config.tenantId, app);
-    return app;
-  }
-
-  get(tenantId: string): ITenantApp {
-    const app = this.tenants.get(tenantId);
-    if (!app) {
-      throw new NotFoundError(`Tenant '${tenantId}' not found`);
-    }
-    return app;
-  }
-
-  async remove(tenantId: string): Promise<void> {
-    const app = this.tenants.get(tenantId);
-    if (!app) {
-      throw new NotFoundError(`Tenant '${tenantId}' not found`);
-    }
-    await app.destroy();
-    this.tenants.delete(tenantId);
-  }
-
-  list(): string[] {
-    return Array.from(this.tenants.keys());
-  }
-}

package/src/types/executionContext.ts

@@ -1,16 +0,0 @@
-/**
- * Project-agnostic execution context contract for declarative runtimes.
- * Mirrors the shape used inside the Opal Support App but stays self-contained
- * so the npm package does not depend on repository-local files.
- */
-export interface ExecutionContext {
-  logs: string[];
-  status: "running" | "success" | "error";
-  output: unknown;
-  error?: string;
-  log: (message: string) => void;
-  setOutput: (output: unknown) => void;
-  setError: (error: string) => void;
-}
-
-export default ExecutionContext;