@classytic/arc 1.1.0 → 2.1.3

package/dist/migrations/index.mjs

@@ -0,0 +1,260 @@
+import mongoose from "mongoose";
+
+//#region src/migrations/index.ts
+/**
+* Define a migration
+*/
+function defineMigration(migration) {
+	return migration;
+}
+/**
+* Migration Runner
+*
+* Manages execution of migrations with tracking and rollback support.
+*/
+var MigrationRunner = class {
+	collectionName = "_migrations";
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* 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)...\n`);
+		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 toRollback = (await this.getAppliedMigrations()).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)...\n`);
+		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() {
+		return await this.db.collection(this.collectionName).find({}).sort({ appliedAt: 1 }).toArray();
+	}
+	/**
+	* 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) {
+		return (await this.getPendingMigrations(migrations)).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) {
+					if (!await migration.validate(this.db)) 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) {
+		await this.db.collection(this.collectionName).insertOne({
+			version: migration.version,
+			resource: migration.resource,
+			description: migration.description,
+			appliedAt: /* @__PURE__ */ new Date(),
+			executionTime
+		});
+	}
+	/**
+	* Remove a migration record
+	*/
+	async removeMigration(migration) {
+		await this.db.collection(this.collectionName).deleteOne({
+			version: migration.version,
+			resource: migration.resource
+		});
+	}
+};
+/**
+* Add versioning to resource definition
+*
+* @example
+* export default defineResource({
+*   name: 'product',
+*   version: 2,
+*   migrations: [productV1ToV2Migration],
+*   // ... rest of resource definition
+* });
+*/
+function withSchemaVersion(version, migrations) {
+	return {
+		version,
+		migrations
+	};
+}
+/**
+* Global migration registry
+*/
+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) {
+		return (this.migrations.get(resource) || []).find((m) => m.version === version);
+	}
+	/**
+	* Clear all registrations
+	*/
+	clear() {
+		this.migrations.clear();
+	}
+};
+/**
+* Global migration registry instance
+*/
+const migrationRegistry = new MigrationRegistry();
+/**
+* Common migration helpers
+*/
+const migrationHelpers = {
+	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 } });
+		}
+	}),
+	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]: "" } });
+		}
+	}),
+	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`);
+		}
+	}),
+	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 = typeof options?.name === "string" ? options.name : Object.keys(fields).join("_");
+			await db.collection(collection).dropIndex(indexName);
+		}
+	})
+};
+
+//#endregion
+export { MigrationRegistry, MigrationRunner, defineMigration, migrationHelpers, migrationRegistry, withSchemaVersion };

package/dist/mongodb-ClykrfGo.d.mts

@@ -0,0 +1,118 @@
+import { i as UserBase } from "./types-RLkFVgaw.mjs";
+
+//#region src/audit/stores/interface.d.ts
+type AuditAction = 'create' | 'update' | 'delete' | 'restore' | 'custom';
+interface AuditEntry {
+  /** Unique audit log ID */
+  id: string;
+  /** Resource name (e.g., 'product', 'user') */
+  resource: string;
+  /** Document/entity ID */
+  documentId: string;
+  /** Action performed */
+  action: AuditAction;
+  /** User who performed the action */
+  userId?: string;
+  /** Organization context */
+  organizationId?: string;
+  /** Previous state (for updates) */
+  before?: Record<string, unknown>;
+  /** New state (for creates/updates) */
+  after?: Record<string, unknown>;
+  /** Changed fields (for updates) */
+  changes?: string[];
+  /** Request ID for tracing */
+  requestId?: string;
+  /** IP address */
+  ipAddress?: string;
+  /** User agent */
+  userAgent?: string;
+  /** Custom metadata */
+  metadata?: Record<string, unknown>;
+  /** When the action occurred */
+  timestamp: Date;
+}
+interface AuditContext {
+  user?: UserBase;
+  organizationId?: string;
+  requestId?: string;
+  ipAddress?: string;
+  userAgent?: string;
+  /** HTTP method + route pattern (e.g., 'PATCH /api/products/:id') */
+  endpoint?: string;
+  /** Request duration in milliseconds */
+  duration?: number;
+}
+interface AuditStoreOptions {
+  /** Store name for logging */
+  name: string;
+}
+/**
+ * Abstract audit store interface
+ */
+interface AuditStore {
+  /** Store name */
+  readonly name: string;
+  /** Log an audit entry */
+  log(entry: AuditEntry): Promise<void>;
+  /** Query audit logs (optional - not all stores support querying) */
+  query?(options: AuditQueryOptions): Promise<AuditEntry[]>;
+  /** Close/cleanup (optional) */
+  close?(): Promise<void>;
+}
+interface AuditQueryOptions {
+  resource?: string;
+  documentId?: string;
+  userId?: string;
+  organizationId?: string;
+  action?: AuditAction | AuditAction[];
+  from?: Date;
+  to?: Date;
+  limit?: number;
+  offset?: number;
+}
+/**
+ * Create audit entry from context
+ */
+declare function createAuditEntry(resource: string, documentId: string, action: AuditAction, context: AuditContext, data?: {
+  before?: Record<string, unknown>;
+  after?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}): AuditEntry;
+//#endregion
+//#region src/audit/stores/mongodb.d.ts
+interface MongoAuditStoreOptions {
+  /** MongoDB connection or mongoose instance */
+  connection: MongoConnection;
+  /** Collection name (default: 'audit_logs') */
+  collection?: string;
+  /** TTL in days (default: 90, 0 = no expiry) */
+  ttlDays?: number;
+}
+interface MongoConnection {
+  collection: (name: string) => MongoCollection;
+}
+interface MongoCollection {
+  insertOne: (doc: Record<string, unknown>) => Promise<unknown>;
+  find: (query: Record<string, unknown>) => MongoCursor;
+  createIndex: (spec: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+}
+interface MongoCursor {
+  sort: (spec: Record<string, unknown>) => MongoCursor;
+  skip: (n: number) => MongoCursor;
+  limit: (n: number) => MongoCursor;
+  toArray: () => Promise<Record<string, unknown>[]>;
+}
+declare class MongoAuditStore implements AuditStore {
+  readonly name = "mongodb";
+  private collection;
+  private initialized;
+  private ttlDays;
+  private options;
+  constructor(options: MongoAuditStoreOptions);
+  private ensureIndexes;
+  log(entry: AuditEntry): Promise<void>;
+  query(options?: AuditQueryOptions): Promise<AuditEntry[]>;
+}
+//#endregion
+export { AuditContext as a, AuditStore as c, AuditAction as i, AuditStoreOptions as l, MongoAuditStoreOptions as n, AuditEntry as o, MongoConnection as r, AuditQueryOptions as s, MongoAuditStore as t, createAuditEntry as u };

package/dist/mongodb-DNKEExbf.mjs

@@ -0,0 +1,93 @@
+//#region src/audit/stores/mongodb.ts
+var MongoAuditStore = class {
+	name = "mongodb";
+	collection;
+	initialized = false;
+	ttlDays;
+	options;
+	constructor(options) {
+		this.options = options;
+		const collectionName = options.collection ?? "audit_logs";
+		this.collection = options.connection.collection(collectionName);
+		this.ttlDays = options.ttlDays ?? 90;
+	}
+	async ensureIndexes() {
+		if (this.initialized) return;
+		try {
+			await this.collection.createIndex({
+				resource: 1,
+				documentId: 1,
+				timestamp: -1
+			});
+			await this.collection.createIndex({
+				userId: 1,
+				timestamp: -1
+			});
+			await this.collection.createIndex({
+				organizationId: 1,
+				timestamp: -1
+			});
+			if (this.ttlDays > 0) await this.collection.createIndex({ timestamp: 1 }, { expireAfterSeconds: this.ttlDays * 24 * 60 * 60 });
+			this.initialized = true;
+		} catch {
+			this.initialized = true;
+		}
+	}
+	async log(entry) {
+		await this.ensureIndexes();
+		await this.collection.insertOne({
+			_id: entry.id,
+			resource: entry.resource,
+			documentId: entry.documentId,
+			action: entry.action,
+			userId: entry.userId,
+			organizationId: entry.organizationId,
+			before: entry.before,
+			after: entry.after,
+			changes: entry.changes,
+			requestId: entry.requestId,
+			ipAddress: entry.ipAddress,
+			userAgent: entry.userAgent,
+			metadata: entry.metadata,
+			timestamp: entry.timestamp
+		});
+	}
+	async query(options = {}) {
+		await this.ensureIndexes();
+		const query = {};
+		if (options.resource) query.resource = options.resource;
+		if (options.documentId) query.documentId = options.documentId;
+		if (options.userId) query.userId = options.userId;
+		if (options.organizationId) query.organizationId = options.organizationId;
+		if (options.action) {
+			const actions = Array.isArray(options.action) ? options.action : [options.action];
+			query.action = actions.length === 1 ? actions[0] : { $in: actions };
+		}
+		if (options.from || options.to) {
+			query.timestamp = {};
+			if (options.from) query.timestamp.$gte = options.from;
+			if (options.to) query.timestamp.$lte = options.to;
+		}
+		const offset = options.offset ?? 0;
+		const limit = options.limit ?? 100;
+		return (await this.collection.find(query).sort({ timestamp: -1 }).skip(offset).limit(limit).toArray()).map((doc) => ({
+			id: String(doc._id),
+			resource: doc.resource,
+			documentId: doc.documentId,
+			action: doc.action,
+			userId: doc.userId,
+			organizationId: doc.organizationId,
+			before: doc.before,
+			after: doc.after,
+			changes: doc.changes,
+			requestId: doc.requestId,
+			ipAddress: doc.ipAddress,
+			userAgent: doc.userAgent,
+			metadata: doc.metadata,
+			timestamp: doc.timestamp
+		}));
+	}
+};
+
+//#endregion
+export { MongoAuditStore as t };

package/dist/mongodb-Dg8O_gvd.d.mts

@@ -0,0 +1,71 @@
+import { n as IdempotencyResult, r as IdempotencyStore } from "./interface-CSNjltAc.mjs";
+
+//#region src/idempotency/stores/mongodb.d.ts
+interface MongoConnection {
+  db: {
+    collection(name: string): MongoCollection;
+  };
+}
+interface MongoCollection {
+  findOne(filter: object): Promise<IdempotencyDocument | null>;
+  insertOne(doc: object): Promise<{
+    acknowledged: boolean;
+  }>;
+  updateOne(filter: object, update: object, options?: object): Promise<{
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+  }>;
+  deleteOne(filter: object): Promise<{
+    deletedCount: number;
+  }>;
+  deleteMany(filter: object): Promise<{
+    deletedCount: number;
+  }>;
+  createIndex(spec: object, options?: object): Promise<string>;
+}
+interface IdempotencyDocument {
+  _id: string;
+  result?: {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: unknown;
+  };
+  lock?: {
+    requestId: string;
+    expiresAt: Date;
+  };
+  createdAt: Date;
+  expiresAt: Date;
+}
+interface MongoIdempotencyStoreOptions {
+  /** Mongoose connection or MongoDB connection object */
+  connection: MongoConnection;
+  /** Collection name (default: 'arc_idempotency') */
+  collection?: string;
+  /** Create TTL index on startup (default: true) */
+  createIndex?: boolean;
+  /** Default TTL in ms (default: 86400000 = 24 hours) */
+  ttlMs?: number;
+}
+declare class MongoIdempotencyStore implements IdempotencyStore {
+  readonly name = "mongodb";
+  private connection;
+  private collectionName;
+  private ttlMs;
+  private indexCreated;
+  constructor(options: MongoIdempotencyStoreOptions);
+  private get collection();
+  private ensureIndex;
+  get(key: string): Promise<IdempotencyResult | undefined>;
+  set(key: string, result: Omit<IdempotencyResult, 'key'>): Promise<void>;
+  tryLock(key: string, requestId: string, ttlMs: number): Promise<boolean>;
+  unlock(key: string, requestId: string): Promise<void>;
+  isLocked(key: string): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  deleteByPrefix(prefix: string): Promise<number>;
+  findByPrefix(prefix: string): Promise<IdempotencyResult | undefined>;
+  close(): Promise<void>;
+}
+//#endregion
+export { MongoIdempotencyStoreOptions as n, MongoIdempotencyStore as t };