@classytic/arc 1.1.0 → 2.1.2

package/dist/migrations/index.d.ts

@@ -1,185 +0,0 @@
-import mongoose from 'mongoose';
-
-/**
- * Schema Versioning and Migrations System
- *
- * Manages database schema changes over time with version tracking.
- * Supports forward migrations, rollbacks, and schema compatibility layers.
- *
- * @example
- * import { defineMigration, MigrationRunner } from '@classytic/arc/migrations';
- *
- * const productV2 = defineMigration({
- *   version: 2,
- *   resource: 'product',
- *   up: async (db) => {
- *     await db.collection('products').updateMany(
- *       {},
- *       { $rename: { 'oldField': 'newField' } }
- *     );
- *   },
- *   down: async (db) => {
- *     await db.collection('products').updateMany(
- *       {},
- *       { $rename: { 'newField': 'oldField' } }
- *     );
- *   },
- * });
- *
- * const runner = new MigrationRunner(mongoose.connection.db);
- * await runner.up(); // Run all pending migrations
- */
-
-interface Migration {
-    /** Migration version (sequential number) */
-    version: number;
-    /** Resource name this migration applies to */
-    resource: string;
-    /** Description of the migration */
-    description?: string;
-    /**
-     * Forward migration (apply schema change)
-     */
-    up: (db: mongoose.mongo.Db) => Promise<void>;
-    /**
-     * Backward migration (revert schema change)
-     */
-    down: (db: mongoose.mongo.Db) => Promise<void>;
-    /**
-     * Optional validation that data is compatible after migration
-     */
-    validate?: (db: mongoose.mongo.Db) => Promise<boolean>;
-}
-interface MigrationRecord {
-    version: number;
-    resource: string;
-    description?: string;
-    appliedAt: Date;
-    executionTime: number;
-}
-/**
- * Define a migration
- */
-declare function defineMigration(migration: Migration): Migration;
-/**
- * Migration Runner
- *
- * Manages execution of migrations with tracking and rollback support.
- */
-declare class MigrationRunner {
-    private readonly db;
-    private readonly collectionName;
-    constructor(db: mongoose.mongo.Db);
-    /**
-     * Run all pending migrations
-     */
-    up(migrations: Migration[]): Promise<void>;
-    /**
-     * Rollback last migration
-     */
-    down(migrations: Migration[]): Promise<void>;
-    /**
-     * Rollback to specific version
-     */
-    downTo(migrations: Migration[], targetVersion: number): Promise<void>;
-    /**
-     * Get all applied migrations
-     */
-    getAppliedMigrations(): Promise<MigrationRecord[]>;
-    /**
-     * Get pending migrations
-     */
-    getPendingMigrations(migrations: Migration[]): Promise<Migration[]>;
-    /**
-     * Check if migrations are up to date
-     */
-    isUpToDate(migrations: Migration[]): Promise<boolean>;
-    /**
-     * Run a single migration
-     */
-    private runMigration;
-    /**
-     * Record a completed migration
-     */
-    private recordMigration;
-    /**
-     * Remove a migration record
-     */
-    private removeMigration;
-}
-/**
- * Schema version definition for resources
- */
-interface SchemaVersion {
-    version: number;
-    migrations: Migration[];
-}
-/**
- * Add versioning to resource definition
- *
- * @example
- * export default defineResource({
- *   name: 'product',
- *   version: 2,
- *   migrations: [productV1ToV2Migration],
- *   // ... rest of resource definition
- * });
- */
-declare function withSchemaVersion(version: number, migrations: Migration[]): SchemaVersion;
-/**
- * Global migration registry
- */
-declare class MigrationRegistry {
-    private migrations;
-    /**
-     * Register a migration
-     */
-    register(migration: Migration): void;
-    /**
-     * Register multiple migrations
-     */
-    registerMany(migrations: Migration[]): void;
-    /**
-     * Get all migrations for a resource
-     */
-    getForResource(resource: string): Migration[];
-    /**
-     * Get all migrations
-     */
-    getAll(): Migration[];
-    /**
-     * Get migration by resource and version
-     */
-    get(resource: string, version: number): Migration | undefined;
-    /**
-     * Clear all registrations
-     */
-    clear(): void;
-}
-/**
- * Global migration registry instance
- */
-declare const migrationRegistry: MigrationRegistry;
-/**
- * Common migration helpers
- */
-declare const migrationHelpers: {
-    /**
-     * Rename a field across all documents
-     */
-    renameField: (collection: string, oldName: string, newName: string) => Migration;
-    /**
-     * Add a new field with default value
-     */
-    addField: (collection: string, fieldName: string, defaultValue: any) => Migration;
-    /**
-     * Remove a field
-     */
-    removeField: (collection: string, fieldName: string) => Migration;
-    /**
-     * Create an index
-     */
-    createIndex: (collection: string, fields: Record<string, 1 | -1>, options?: any) => Migration;
-};
-
-export { type Migration, type MigrationRecord, MigrationRegistry, MigrationRunner, type SchemaVersion, defineMigration, migrationHelpers, migrationRegistry, withSchemaVersion };

package/dist/migrations/index.js

@@ -1,274 +0,0 @@
-import 'mongoose';
-
-// src/migrations/index.ts
-function defineMigration(migration) {
-  return migration;
-}
-var MigrationRunner = class {
-  constructor(db) {
-    this.db = db;
-  }
-  collectionName = "_migrations";
-  /**
-   * Run all pending migrations
-   */
-  async up(migrations) {
-    const applied = await this.getAppliedMigrations();
-    const appliedVersions = new Set(applied.map((m) => `${m.resource}:${m.version}`));
-    const pending = migrations.filter((m) => !appliedVersions.has(`${m.resource}:${m.version}`)).sort((a, b) => a.version - b.version);
-    if (pending.length === 0) {
-      console.log("No pending migrations");
-      return;
-    }
-    console.log(`Running ${pending.length} migration(s)...
-`);
-    for (const migration of pending) {
-      await this.runMigration(migration, "up");
-    }
-    console.log("\nAll migrations completed successfully");
-  }
-  /**
-   * Rollback last migration
-   */
-  async down(migrations) {
-    const applied = await this.getAppliedMigrations();
-    if (applied.length === 0) {
-      console.log("No migrations to rollback");
-      return;
-    }
-    const last = applied[applied.length - 1];
-    if (!last) {
-      console.log("No migrations to rollback");
-      return;
-    }
-    const migration = migrations.find(
-      (m) => m.resource === last.resource && m.version === last.version
-    );
-    if (!migration) {
-      throw new Error(
-        `Migration ${last.resource}:${last.version} not found in migration files`
-      );
-    }
-    console.log(`Rolling back ${migration.resource} v${migration.version}...`);
-    await this.runMigration(migration, "down", true);
-    console.log("Rollback completed");
-  }
-  /**
-   * Rollback to specific version
-   */
-  async downTo(migrations, targetVersion) {
-    const applied = await this.getAppliedMigrations();
-    const toRollback = applied.filter((m) => m.version > targetVersion).reverse();
-    if (toRollback.length === 0) {
-      console.log(`Already at or below version ${targetVersion}`);
-      return;
-    }
-    console.log(`Rolling back ${toRollback.length} migration(s)...
-`);
-    for (const record of toRollback) {
-      const migration = migrations.find(
-        (m) => m.resource === record.resource && m.version === record.version
-      );
-      if (!migration) {
-        throw new Error(`Migration ${record.resource}:${record.version} not found`);
-      }
-      await this.runMigration(migration, "down", true);
-    }
-    console.log("\nRollback completed");
-  }
-  /**
-   * Get all applied migrations
-   */
-  async getAppliedMigrations() {
-    const collection = this.db.collection(this.collectionName);
-    const records = await collection.find({}).sort({ appliedAt: 1 }).toArray();
-    return records;
-  }
-  /**
-   * Get pending migrations
-   */
-  async getPendingMigrations(migrations) {
-    const applied = await this.getAppliedMigrations();
-    const appliedVersions = new Set(applied.map((m) => `${m.resource}:${m.version}`));
-    return migrations.filter((m) => !appliedVersions.has(`${m.resource}:${m.version}`));
-  }
-  /**
-   * Check if migrations are up to date
-   */
-  async isUpToDate(migrations) {
-    const pending = await this.getPendingMigrations(migrations);
-    return pending.length === 0;
-  }
-  /**
-   * Run a single migration
-   */
-  async runMigration(migration, direction, isRollback = false) {
-    const start = Date.now();
-    const action = direction === "up" ? "Applying" : "Rolling back";
-    console.log(
-      `${action} ${migration.resource} v${migration.version}${migration.description ? `: ${migration.description}` : ""}...`
-    );
-    try {
-      if (direction === "up") {
-        await migration.up(this.db);
-        if (migration.validate) {
-          const valid = await migration.validate(this.db);
-          if (!valid) {
-            throw new Error("Migration validation failed");
-          }
-        }
-        await this.recordMigration(migration, Date.now() - start);
-      } else {
-        await migration.down(this.db);
-        if (isRollback) {
-          await this.removeMigration(migration);
-        }
-      }
-      const duration = Date.now() - start;
-      console.log(`✅ ${migration.resource} v${migration.version} (${duration}ms)`);
-    } catch (error) {
-      console.error(
-        `❌ ${migration.resource} v${migration.version} failed:`,
-        error.message
-      );
-      throw error;
-    }
-  }
-  /**
-   * Record a completed migration
-   */
-  async recordMigration(migration, executionTime) {
-    const collection = this.db.collection(this.collectionName);
-    await collection.insertOne({
-      version: migration.version,
-      resource: migration.resource,
-      description: migration.description,
-      appliedAt: /* @__PURE__ */ new Date(),
-      executionTime
-    });
-  }
-  /**
-   * Remove a migration record
-   */
-  async removeMigration(migration) {
-    const collection = this.db.collection(this.collectionName);
-    await collection.deleteOne({
-      version: migration.version,
-      resource: migration.resource
-    });
-  }
-};
-function withSchemaVersion(version, migrations) {
-  return { version, migrations };
-}
-var MigrationRegistry = class {
-  migrations = /* @__PURE__ */ new Map();
-  /**
-   * Register a migration
-   */
-  register(migration) {
-    const existing = this.migrations.get(migration.resource) || [];
-    existing.push(migration);
-    existing.sort((a, b) => a.version - b.version);
-    this.migrations.set(migration.resource, existing);
-  }
-  /**
-   * Register multiple migrations
-   */
-  registerMany(migrations) {
-    for (const migration of migrations) {
-      this.register(migration);
-    }
-  }
-  /**
-   * Get all migrations for a resource
-   */
-  getForResource(resource) {
-    return this.migrations.get(resource) || [];
-  }
-  /**
-   * Get all migrations
-   */
-  getAll() {
-    const all = [];
-    for (const migrations of this.migrations.values()) {
-      all.push(...migrations);
-    }
-    return all.sort((a, b) => a.version - b.version);
-  }
-  /**
-   * Get migration by resource and version
-   */
-  get(resource, version) {
-    const migrations = this.migrations.get(resource) || [];
-    return migrations.find((m) => m.version === version);
-  }
-  /**
-   * Clear all registrations
-   */
-  clear() {
-    this.migrations.clear();
-  }
-};
-var migrationRegistry = new MigrationRegistry();
-var migrationHelpers = {
-  /**
-   * Rename a field across all documents
-   */
-  renameField: (collection, oldName, newName) => defineMigration({
-    version: 0,
-    resource: collection,
-    description: `Rename ${oldName} to ${newName}`,
-    up: async (db) => {
-      await db.collection(collection).updateMany({}, { $rename: { [oldName]: newName } });
-    },
-    down: async (db) => {
-      await db.collection(collection).updateMany({}, { $rename: { [newName]: oldName } });
-    }
-  }),
-  /**
-   * Add a new field with default value
-   */
-  addField: (collection, fieldName, defaultValue) => defineMigration({
-    version: 0,
-    resource: collection,
-    description: `Add ${fieldName} field`,
-    up: async (db) => {
-      await db.collection(collection).updateMany({ [fieldName]: { $exists: false } }, { $set: { [fieldName]: defaultValue } });
-    },
-    down: async (db) => {
-      await db.collection(collection).updateMany({}, { $unset: { [fieldName]: "" } });
-    }
-  }),
-  /**
-   * Remove a field
-   */
-  removeField: (collection, fieldName) => defineMigration({
-    version: 0,
-    resource: collection,
-    description: `Remove ${fieldName} field`,
-    up: async (db) => {
-      await db.collection(collection).updateMany({}, { $unset: { [fieldName]: "" } });
-    },
-    down: async (db) => {
-      console.warn(`Cannot restore ${fieldName} field - data was deleted`);
-    }
-  }),
-  /**
-   * Create an index
-   */
-  createIndex: (collection, fields, options) => defineMigration({
-    version: 0,
-    resource: collection,
-    description: `Create index on ${Object.keys(fields).join(", ")}`,
-    up: async (db) => {
-      await db.collection(collection).createIndex(fields, options);
-    },
-    down: async (db) => {
-      const indexName = options?.name || Object.keys(fields).join("_");
-      await db.collection(collection).dropIndex(indexName);
-    }
-  })
-};
-
-export { MigrationRegistry, MigrationRunner, defineMigration, migrationHelpers, migrationRegistry, withSchemaVersion };

package/dist/org/index.d.ts

@@ -1,129 +0,0 @@
-import { RouteHandlerMethod, FastifyPluginAsync } from 'fastify';
-import { b as RequestContext, Z as OrgScopeOptions, z as RouteHandler } from '../index-B4t03KQ0.js';
-import { U as UserBase } from '../types-B99TBmFV.js';
-import 'mongoose';
-
-/**
- * 🏢 Smart Organization Scope Plugin
- *
- * Intelligent organization filtering that adapts to authentication context.
- *
- * Philosophy: "Be Lenient with Public, Strict with Authenticated"
- * - Public routes: Allow without org filter (shows all)
- * - Authenticated routes: Validate org access
- * - Admin routes: Bypass restrictions
- *
- * Usage Pattern:
- * - This plugin adds a `organizationScoped()` decorator factory to fastify
- * - Apply it per-route as preHandler, NOT as a global hook
- * - Resources can opt-in to org scoping individually
- *
- * @example
- * // Register the plugin
- * await fastify.register(orgScopePlugin, {
- *   header: 'x-organization-id',
- *   bypassRoles: ['superadmin'],
- * });
- *
- * // Use per-route (required org)
- * fastify.get('/invoices', {
- *   preHandler: [fastify.authenticate, fastify.organizationScoped({ required: true })]
- * }, handler);
- *
- * // Optional org scoping (shows all if no header)
- * fastify.get('/products', {
- *   preHandler: [fastify.organizationScoped({ required: false })]
- * }, handler);
- */
-
-interface OrganizationScopedOptions {
-    /** Require org header (default: true) */
-    required?: boolean;
-}
-declare module 'fastify' {
-    interface FastifyRequest {
-        context?: RequestContext;
-        organizationId?: string;
-    }
-    interface FastifyInstance {
-        organizationScoped: (options?: OrganizationScopedOptions) => RouteHandlerMethod;
-        createOrgContext: (orgId: string, options?: Partial<RequestContext>) => RequestContext;
-    }
-}
-/**
- * Create org context object
- */
-declare function createOrgContext(orgId: string, options?: Partial<RequestContext>): RequestContext;
-declare const orgScopePlugin: FastifyPluginAsync<OrgScopeOptions>;
-declare const _default: FastifyPluginAsync<OrgScopeOptions>;
-
-/**
- * Organization Guard Middleware
- *
- * Ensures organization context is present before handler execution.
- *
- * @example
- * // Require org context
- * fastify.get('/invoices', {
- *   preHandler: [fastify.authenticate, orgGuard()]
- * }, handler);
- *
- * // Require specific org roles
- * fastify.post('/invoices', {
- *   preHandler: [fastify.authenticate, orgGuard({ roles: ['admin', 'accountant'] })]
- * }, handler);
- */
-
-interface OrgGuardOptions {
-    /** Require organization context (default: true) */
-    requireOrgContext?: boolean;
-    /** Required org-level roles */
-    roles?: string[];
-    /** Allow superadmin without org context */
-    allowGlobal?: boolean;
-}
-/**
- * Create org guard middleware
- */
-declare function orgGuard(options?: OrgGuardOptions): RouteHandler;
-/**
- * Shorthand for requiring org context
- */
-declare function requireOrg(): RouteHandler;
-/**
- * Require org context with specific roles
- */
-declare function requireOrgRole(...roles: string[]): RouteHandler;
-
-/**
- * Organization Membership Utilities
- *
- * Server-side membership validation.
- */
-
-interface OrgMembershipOptions {
-    /** Path to user's organizations array */
-    userOrgsPath?: string;
-    /** Roles that bypass membership check */
-    bypassRoles?: string[];
-    /** Optional DB lookup function */
-    validateFromDb?: (userId: string, orgId: string) => Promise<boolean>;
-}
-interface OrgRolesOptions {
-    /** Path to user's organizations array */
-    userOrgsPath?: string;
-}
-/**
- * Check if user is member of organization
- */
-declare function orgMembershipCheck(user: UserBase | undefined | null, orgId: string | undefined | null, options?: OrgMembershipOptions): Promise<boolean>;
-/**
- * Get user's role in organization
- */
-declare function getOrgRoles(user: UserBase | undefined | null, orgId: string | undefined | null, options?: OrgRolesOptions): string[];
-/**
- * Check if user has specific role in organization
- */
-declare function hasOrgRole(user: UserBase | undefined | null, orgId: string | undefined | null, roles: string | string[], options?: OrgRolesOptions): boolean;
-
-export { type OrgGuardOptions, type OrgMembershipOptions, type OrgRolesOptions, OrgScopeOptions, type OrganizationScopedOptions, createOrgContext, getOrgRoles, hasOrgRole, orgGuard, orgMembershipCheck, _default as orgScopePlugin, orgScopePlugin as orgScopePluginFn, requireOrg, requireOrgRole };