intellitester 0.1.12

package/dist/core/cleanup/index.d.ts

@@ -0,0 +1,117 @@
+import { a as CleanupHandler, E as ExecutorOptions, b as CleanupConfig, C as CleanupProvider, c as CleanupResult } from '../../types-l-ZaFKC-.js';
+export { f as CleanupDiscoverConfig, d as CleanupUntrackedOptions, e as CleanupUntrackedResult } from '../../types-l-ZaFKC-.js';
+import { TrackedResource } from '../../integration/index.js';
+
+/**
+ * Extended options for cleanup execution including provider and config
+ */
+interface ExtendedCleanupOptions extends ExecutorOptions {
+    config?: CleanupConfig;
+    provider?: CleanupProvider;
+}
+/**
+ * Execute cleanup for all tracked resources
+ *
+ * @param resources - Array of tracked resources to clean up
+ * @param handlers - Map of handler names to cleanup functions
+ * @param typeMappings - Map of resource types to handler names
+ * @param options - Executor options (parallel, retries, config, provider)
+ */
+declare function executeCleanup(resources: TrackedResource[], handlers: Map<string, CleanupHandler>, typeMappings: Record<string, string>, options?: ExtendedCleanupOptions): Promise<CleanupResult>;
+/**
+ * Create a cleanup executor with pre-configured handlers and options
+ */
+declare function createCleanupExecutor(handlers: Map<string, CleanupHandler>, typeMappings: Record<string, string>, options?: ExecutorOptions): {
+    /**
+     * Execute cleanup for resources
+     */
+    cleanup: (resources: TrackedResource[]) => Promise<CleanupResult>;
+    /**
+     * Execute cleanup for a single resource
+     */
+    cleanupOne: (resource: TrackedResource) => Promise<boolean>;
+};
+
+/**
+ * Load all cleanup handlers based on configuration
+ *
+ * Loading order (later overrides earlier):
+ * 1. Built-in provider methods
+ * 2. intellitester.cleanup.ts at project root
+ * 3. Discovery paths (default: tests/cleanup/**\/*.ts)
+ * 4. Explicit handler files from config
+ *
+ * @param config - Cleanup configuration object
+ * @param cwd - Current working directory (defaults to process.cwd())
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with a provider
+ * const { handlers, typeMappings } = await loadCleanupHandlers({
+ *   provider: 'sqlite',
+ *   sqlite: { database: './test.db' },
+ *   types: {
+ *     user: 'sqlite.deleteUser',
+ *     team: 'sqlite.deleteRow'
+ *   }
+ * });
+ *
+ * // With custom discovery paths
+ * const { handlers, typeMappings } = await loadCleanupHandlers({
+ *   provider: 'postgres',
+ *   postgres: { connectionString: 'postgresql://...' },
+ *   discover: {
+ *     enabled: true,
+ *     paths: ['./tests/cleanup', './e2e/cleanup'],
+ *     pattern: '**\/*.cleanup.ts'
+ *   },
+ *   handlers: ['./custom-cleanup.ts']
+ * });
+ * ```
+ *
+ * @returns Object containing loaded handlers map and type mappings
+ */
+declare function loadCleanupHandlers(config: CleanupConfig, cwd?: string): Promise<{
+    handlers: Map<string, CleanupHandler>;
+    typeMappings: Record<string, string>;
+    provider?: CleanupProvider;
+}>;
+/**
+ * Get a handler by key, checking both direct keys and provider.method format
+ */
+declare function resolveHandler(handlers: Map<string, CleanupHandler>, typeMappings: Record<string, string>, resourceType: string): CleanupHandler | null;
+
+interface FailedCleanup {
+    sessionId: string;
+    timestamp: string;
+    resources: TrackedResource[];
+    providerConfig: {
+        provider: string;
+        [key: string]: unknown;
+    };
+    errors: string[];
+}
+declare function saveFailedCleanup(cleanup: FailedCleanup, cwd?: string): Promise<void>;
+declare function loadFailedCleanups(cwd?: string): Promise<FailedCleanup[]>;
+declare function removeFailedCleanup(sessionId: string, cwd?: string): Promise<void>;
+
+/**
+ * Helper for defining cleanup handlers in user files.
+ * Provides type safety for custom cleanup handler definitions.
+ *
+ * @example
+ * // In cleanup.ts
+ * import { defineCleanupHandlers } from 'intellitester/cleanup';
+ *
+ * export default defineCleanupHandlers({
+ *   async deleteUser(resource) {
+ *     // cleanup logic
+ *   },
+ *   async deleteTeam(resource) {
+ *     // cleanup logic
+ *   }
+ * });
+ */
+declare function defineCleanupHandlers<T extends Record<string, CleanupHandler>>(handlers: T): T;
+
+export { CleanupConfig, CleanupHandler, CleanupProvider, CleanupResult, ExecutorOptions, type ExtendedCleanupOptions, type FailedCleanup, createCleanupExecutor, defineCleanupHandlers, executeCleanup, loadCleanupHandlers, loadFailedCleanups, removeFailedCleanup, resolveHandler, saveFailedCleanup };

package/dist/core/cleanup/index.js

@@ -0,0 +1,8 @@
+export { createCleanupExecutor, defineCleanupHandlers, executeCleanup, loadCleanupHandlers, loadFailedCleanups, removeFailedCleanup, resolveHandler, saveFailedCleanup } from '../../chunk-ECBA4GJ3.js';
+import '../../chunk-DE5UFTTG.js';
+import '../../chunk-6PYKWWH5.js';
+import '../../chunk-4B54JUOP.js';
+import '../../chunk-SAVY6D3X.js';
+import '../../chunk-CN6HSJJX.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/core/cleanup/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/index.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+var chunkXWGUA67E_cjs = require('./chunk-XWGUA67E.cjs');
+require('./chunk-ARJYJVRM.cjs');
+require('./chunk-QMYM2TCH.cjs');
+require('./chunk-PAKODOH4.cjs');
+require('./chunk-OFXNJXMV.cjs');
+require('./chunk-UUJXCHVT.cjs');
+require('./chunk-35WJGNDA.cjs');
+
+
+
+Object.defineProperty(exports, "ActionSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.ActionSchema; }
+});
+Object.defineProperty(exports, "IntellitesterConfigSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.IntellitesterConfigSchema; }
+});
+Object.defineProperty(exports, "LocatorSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.LocatorSchema; }
+});
+Object.defineProperty(exports, "TestConfigSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.TestConfigSchema; }
+});
+Object.defineProperty(exports, "TestDefinitionSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.TestDefinitionSchema; }
+});
+Object.defineProperty(exports, "cleanupConfigSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.cleanupConfigSchema; }
+});
+Object.defineProperty(exports, "cleanupDiscoverSchema", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.cleanupDiscoverSchema; }
+});
+Object.defineProperty(exports, "collectMissingEnvVars", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.collectMissingEnvVars; }
+});
+Object.defineProperty(exports, "isPipelineFile", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.isPipelineFile; }
+});
+Object.defineProperty(exports, "isWorkflowFile", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.isWorkflowFile; }
+});
+Object.defineProperty(exports, "killServer", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.killServer; }
+});
+Object.defineProperty(exports, "loadIntellitesterConfig", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.loadIntellitesterConfig; }
+});
+Object.defineProperty(exports, "loadPipelineDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.loadPipelineDefinition; }
+});
+Object.defineProperty(exports, "loadTestDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.loadTestDefinition; }
+});
+Object.defineProperty(exports, "loadWorkflowDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.loadWorkflowDefinition; }
+});
+Object.defineProperty(exports, "parseIntellitesterConfig", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.parseIntellitesterConfig; }
+});
+Object.defineProperty(exports, "parsePipelineDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.parsePipelineDefinition; }
+});
+Object.defineProperty(exports, "parseTestDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.parseTestDefinition; }
+});
+Object.defineProperty(exports, "parseWorkflowDefinition", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.parseWorkflowDefinition; }
+});
+Object.defineProperty(exports, "runWebTest", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.runWebTest; }
+});
+Object.defineProperty(exports, "runWorkflow", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.runWorkflow; }
+});
+Object.defineProperty(exports, "runWorkflowWithContext", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.runWorkflowWithContext; }
+});
+Object.defineProperty(exports, "setupAppwriteTracking", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.setupAppwriteTracking; }
+});
+Object.defineProperty(exports, "startWebServer", {
+  enumerable: true,
+  get: function () { return chunkXWGUA67E_cjs.startWebServer; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}