@asaidimu/anansi 1.1.0 → 1.2.1

package/index.d.cts

@@ -282,36 +282,11 @@ interface Migration<T> {
     checksum: string;
 }
 
-type schemaDefinition_Constraint<T extends FieldType> = Constraint<T>;
-type schemaDefinition_ConstraintGroup<T extends FieldType> = ConstraintGroup<T>;
-type schemaDefinition_ConstraintParameters<T extends FieldType> = ConstraintParameters<T>;
-type schemaDefinition_ConstraintsMap = ConstraintsMap;
-type schemaDefinition_DataTransform<Initial, Next> = DataTransform<Initial, Next>;
-type schemaDefinition_FieldDefinition<T> = FieldDefinition<T>;
-type schemaDefinition_FieldType = FieldType;
-type schemaDefinition_FunctionMap = FunctionMap;
-type schemaDefinition_IndexDefinition = IndexDefinition;
-type schemaDefinition_IndexType = IndexType;
-type schemaDefinition_LogicalOperator = LogicalOperator;
-type schemaDefinition_Migration<T> = Migration<T>;
-type schemaDefinition_PartialIndexCondition = PartialIndexCondition;
-type schemaDefinition_Predicate = Predicate;
-type schemaDefinition_PredicateMap = PredicateMap;
-type schemaDefinition_PredicateName<T extends PredicateMap = any> = PredicateName<T>;
-type schemaDefinition_PredicateParameters<T extends FieldType> = PredicateParameters<T>;
-type schemaDefinition_SchemaChange<T> = SchemaChange<T>;
-type schemaDefinition_SchemaConstraint<T extends FieldType> = SchemaConstraint<T>;
-type schemaDefinition_SchemaDefinition = SchemaDefinition;
-type schemaDefinition_TransformFunction<Initial, Next> = TransformFunction<Initial, Next>;
-declare namespace schemaDefinition {
-  export type { schemaDefinition_Constraint as Constraint, schemaDefinition_ConstraintGroup as ConstraintGroup, schemaDefinition_ConstraintParameters as ConstraintParameters, schemaDefinition_ConstraintsMap as ConstraintsMap, schemaDefinition_DataTransform as DataTransform, schemaDefinition_FieldDefinition as FieldDefinition, schemaDefinition_FieldType as FieldType, schemaDefinition_FunctionMap as FunctionMap, schemaDefinition_IndexDefinition as IndexDefinition, schemaDefinition_IndexType as IndexType, schemaDefinition_LogicalOperator as LogicalOperator, schemaDefinition_Migration as Migration, schemaDefinition_PartialIndexCondition as PartialIndexCondition, schemaDefinition_Predicate as Predicate, schemaDefinition_PredicateMap as PredicateMap, schemaDefinition_PredicateName as PredicateName, schemaDefinition_PredicateParameters as PredicateParameters, schemaDefinition_SchemaChange as SchemaChange, schemaDefinition_SchemaConstraint as SchemaConstraint, schemaDefinition_SchemaDefinition as SchemaDefinition, schemaDefinition_TransformFunction as TransformFunction };
-}
-
 /**
  * Defines the interface for a migration engine.
  * The migration engine is responsible for applying, rolling back, and tracking schema migrations.
  */
-interface MigrationEngine$1<T> {
+interface MigrationEngine<T> {
     /**
      * Applies all pending migrations.
      * @returns A promise that resolves when all migrations are applied.
@@ -362,10 +337,6 @@ interface MigrationEngine$1<T> {
     removeMigration(migrationId: string): Promise<void>;
 }
 
-declare namespace migrations {
-  export type { MigrationEngine$1 as MigrationEngine };
-}
-
 /**
  * @module JsonPatch
  * @description A library for creating and applying JSON Patch operations according to RFC 6902
@@ -442,17 +413,6 @@ declare function createPatch(oldObj: any, newObj: any): PatchOperation[];
  */
 declare function schemaChangeToPatch(change: SchemaChange<any>, schema: SchemaDefinition): PatchOperation[];
 
-type patch_JsonPatchError = JsonPatchError;
-declare const patch_JsonPatchError: typeof JsonPatchError;
-type patch_PatchOperation = PatchOperation;
-declare const patch_applyPatch: typeof applyPatch;
-declare const patch_createPatch: typeof createPatch;
-declare const patch_normalizePath: typeof normalizePath;
-declare const patch_schemaChangeToPatch: typeof schemaChangeToPatch;
-declare namespace patch {
-  export { patch_JsonPatchError as JsonPatchError, type patch_PatchOperation as PatchOperation, patch_applyPatch as applyPatch, patch_createPatch as createPatch, patch_normalizePath as normalizePath, patch_schemaChangeToPatch as schemaChangeToPatch };
-}
-
 /**
  * Helper for building schema migrations.
  * @template T The type of data associated with the schema.
@@ -702,15 +662,6 @@ interface PersistenceEvent<DataType> {
     context?: Record<string, any>;
 }
 
-type persistence_Persistence<FunctionMap> = Persistence<FunctionMap>;
-type persistence_PersistenceCollection<T, FunctionMap> = PersistenceCollection<T, FunctionMap>;
-type persistence_PersistenceEvent<DataType> = PersistenceEvent<DataType>;
-type persistence_PersistenceEventType = PersistenceEventType;
-type persistence_PersistenceTransaction<F> = PersistenceTransaction<F>;
-declare namespace persistence {
-  export type { persistence_Persistence as Persistence, persistence_PersistenceCollection as PersistenceCollection, persistence_PersistenceEvent as PersistenceEvent, persistence_PersistenceEventType as PersistenceEventType, persistence_PersistenceTransaction as PersistenceTransaction };
-}
-
 type SchemaIndex = {
     schema: string;
     version: string;
@@ -776,45 +727,6 @@ interface SchemaRegistry {
     history(name: string): Promise<SchemaDefinition[]>;
 }
 
-type registry_MigrationMetadata = MigrationMetadata;
-type registry_RegistryLock = RegistryLock;
-type registry_RegistryMetadata = RegistryMetadata;
-type registry_SchemaIndex = SchemaIndex;
-type registry_SchemaMetadata = SchemaMetadata;
-type registry_SchemaRegistry = SchemaRegistry;
-type registry_SchemaVersion = SchemaVersion;
-declare namespace registry {
-  export type { registry_MigrationMetadata as MigrationMetadata, registry_RegistryLock as RegistryLock, registry_RegistryMetadata as RegistryMetadata, registry_SchemaIndex as SchemaIndex, registry_SchemaMetadata as SchemaMetadata, registry_SchemaRegistry as SchemaRegistry, registry_SchemaVersion as SchemaVersion };
-}
-
-/**
- * Creates an ephemeral persistence instance with in-memory storage.
- * @template {PredicateMap} Predicates
- * @template FunctionMap
- * @param {FunctionMap} functionMap - Map of function names to their implementations
- * @param {Predicates} predicateMap - Map of predicate names to their implementations
- * @returns {Persistence<FunctionMap>} A persistence instance
- */
-declare function createEphemeralPersistence<Predicates extends PredicateMap, FunctionMap>(functionMap: FunctionMap, predicateMap: Predicates): Persistence<FunctionMap>;
-
-declare namespace index$3 {
-  export { createEphemeralPersistence as default };
-}
-
-/**
- * Creates and returns a new SchemaRegistry instance.
- * @returns {Promise<SchemaRegistry>} A promise that resolves to the SchemaRegistry instance.
- */
-declare function createRegistry(credentials: {
-    username: string;
-    password: string;
-    repository: string;
-}, dir?: string, proxy?: string): Promise<SchemaRegistry>;
-
-declare namespace index$2 {
-  export { createRegistry as default };
-}
-
 /**
  * @fileoverview Provides a MigrationEngine class that handles schema migrations,
  * including validation, checksum generation, and migration application.
@@ -853,198 +765,6 @@ declare enum MigrationErrorCode {
     ROLLBACK_ERROR = "ROLLBACK_ERROR",
     MISSING_TRANSFORM = "MISSING_TRANSFORM"
 }
-/**
- * @class MigrationEngine
- * @param {SchemaDefinition} currentSchema - The current schema definition
- * @param {Array<Migration<any>>} [migrations] - Optional array of migrations
- * @throws {MigrationError} If the initial schema or migrations are invalid
- */
-declare class MigrationEngine {
-    private currentSchema;
-    private history;
-    private migrations;
-    private isProcessing;
-    /**
-     * @constructor
-     * @param {SchemaDefinition} currentSchema - The current schema definition
-     * @param {Array<Migration<any>>} [migrations] - Optional array of migrations
-     */
-    constructor(currentSchema: SchemaDefinition, migrations?: Array<Migration<any>>, history?: Array<SchemaDefinition>);
-    /**
-     * Gets the current state of the migration helper
-     * @returns {Object} Current state containing schema, history, and migrations
-     * @example
-     * ```javascript
-     * const state = migrationEngine.data();
-     * // state contains currentSchema, history, and migrations
-     * ```
-     */
-    data(): {
-        schema: SchemaDefinition;
-        history: SchemaDefinition[];
-        migrations: Migration<any>[];
-    };
-    /**
-     * Generates a SHA-256 checksum for a migration
-     * @private
-     * @param {Omit<Migration<any>, "checksum">} migration - The migration object
-     * @returns {Promise<string>} The generated checksum
-     * @throws {MigrationError} If checksum generation fails
-     */
-    private generateChecksum;
-    /**
-     * Adds a new migration to the engine
-     * @async
-     * @param {Object} opts - Options for the new migration
-     * @param {SchemaChange<any>[]} opts.changes - Array of schema changes
-     * @param {string} opts.description - Description of the migration
-     * @param {SchemaChange<any>[]} [opts.rollback] - Optional rollback changes
-     * @param {DataTransform<any, any>} [opts.transform] - Optional data transform
-     * @throws {MigrationError} If adding the migration fails
-     */
-    add(opts: {
-        changes: SchemaChange<any>[];
-        description: string;
-        rollback?: SchemaChange<any>[];
-        transform?: string | DataTransform<any, any>;
-    }): Promise<void>;
-    /**
-     * Performs a dry run of the migration
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @param {version} version - Version to rollback to
-     * @returns {Promise<Object>} Object containing newSchema and dataPreview
-     * @throws {MigrationError} If dry run fails
-     */
-    dryRun(input: ReadableStream<any>, direction: "forward" | "backward", version?: string): Promise<{
-        newSchema: SchemaDefinition;
-        dataPreview: ReadableStream<any>;
-    }>;
-    /**
-     * Gets relevant migrations based on direction
-     * @private
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Array<Migration<any>>} Relevant migrations
-     */
-    private getRelevantMigrations;
-    /**
-     * Applies schema changes to a given schema
-     * @private
-     * @param {SchemaDefinition} schema - The schema to modify
-     * @param {SchemaChange<any>[]} changes - Array of schema changes
-     * @param {string} [migrationId] - ID of the migration
-     * @returns {SchemaDefinition} Modified schema
-     * @throws {MigrationError} If applying changes fails
-     */
-    private applySchemaChanges;
-    /**
-     * Prepares the list of pending migrations for application
-     * @async
-     * @returns {Promise<Array<Migration<any>>} List of pending migrations
-     * @throws {MigrationError} If preparation fails
-     */
-    prepareMigration(): Promise<Array<Migration<any>>>;
-    /**
-     * Applies pending migrations
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {MigrationError} If migration fails
-     */
-    migrate(input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Validates migrations by checking their checksums
-     * @private
-     * @async
-     * @param {Array<Migration<any>>} migrations - Migrations to validate
-     * @throws {MigrationError} If validation fails
-     */
-    private validateMigrations;
-    /**
-     * Marks migrations as applied
-     * @private
-     * @param {Array<Migration<any>>} migrations - Migrations to mark as applied
-     */
-    private markMigrationsApplied;
-    /**
-     * Rolls back the last applied migration
-     * @async
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     */
-    rollback(input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Rolls back to a specific schema version
-     * @async
-     * @param {string} targetVersion - Target schema version
-     * @param {ReadableStream<any>} input - Input data stream
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {Error} If target version is not found
-     */
-    rollbackToVersion(targetVersion: string, input: ReadableStream<any>): Promise<ReadableStream<any>>;
-    /**
-     * Processes a list of migrations on a data stream, applying transformations
-     * in the specified direction (forward or backward).
-     *
-     * @static
-     * @async
-     * @param {ReadableStream<any>} input - The input data stream to process
-     * @param {"forward" | "backward"} direction - Direction of migration (either "forward" or "backward")
-     * @param {Array<Migration<any>>} migrations - Array of Migration objects to process
-     * @returns {Promise<ReadableStream<any>>} Transformed data stream
-     * @throws {MigrationError} If any migration processing fails
-     */
-    static processMigrationList(input: ReadableStream<any>, direction: "forward" | "backward", migrations: Migration<any>[]): Promise<ReadableStream<any>>;
-    /**
-     * Resolves the transform function for a given migration in the specified direction.
-     *
-     * @private
-     * @async
-     * @param {Migration<any>} migration - The migration to resolve the transform for
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If transform resolution fails
-     */
-    private static resolveTransform;
-    /**
-     * Resolves a transform function from a remote URL.
-     *
-     * @private
-     * @async
-     * @param {string} url - URL of the transform module
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If resolution fails
-     */
-    private static resolveRemoteTransform;
-    /**
-     * Resolves a transform function from a local module path.
-     *
-     * @private
-     * @async
-     * @param {string} path - Local module path
-     * @param {"forward" | "backward"} direction - Direction of migration
-     * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
-     * @throws {MigrationError} If resolution fails
-     */
-    private static resolveLocalTransform;
-    /**
-     * Transforms the schema either forward or backward
-     * @private
-     * @param {"forward" | "backward"} direction - Direction of transformation
-     * @throws {Error} If transformation fails
-     */
-    private transformSchema;
-}
-
-type index$1_MigrationError = MigrationError;
-declare const index$1_MigrationError: typeof MigrationError;
-type index$1_MigrationErrorCode = MigrationErrorCode;
-declare const index$1_MigrationErrorCode: typeof MigrationErrorCode;
-declare namespace index$1 {
-  export { index$1_MigrationError as MigrationError, index$1_MigrationErrorCode as MigrationErrorCode, MigrationEngine as default };
-}
 
 /**
  * Helper for building schema migrations with forward and rollback changes.
@@ -1814,16 +1534,6 @@ declare function validateSchemaChange<T>(change: any): change is SchemaChange<T>
 declare function validateSchemaDefinition(schema: any): schema is SchemaDefinition;
 declare const validate: typeof validateSchemaDefinition;
 
-declare const index_MigrationSchema: typeof MigrationSchema;
-declare const index_createSchemaMigrationHelper: typeof createSchemaMigrationHelper;
-declare const index_validate: typeof validate;
-declare const index_validateMigration: typeof validateMigration;
-declare const index_validateSchemaChange: typeof validateSchemaChange;
-declare const index_validateSchemaDefinition: typeof validateSchemaDefinition;
-declare namespace index {
-  export { index_MigrationSchema as MigrationSchema, index_createSchemaMigrationHelper as createSchemaMigrationHelper, index_validate as validate, index_validateMigration as validateMigration, index_validateSchemaChange as validateSchemaChange, index_validateSchemaDefinition as validateSchemaDefinition };
-}
-
 /**
  * Generates a SHA-256 hash of the input string.
  *
@@ -1832,11 +1542,6 @@ declare namespace index {
  */
 declare const generateSHA256Hash: (input: string) => Promise<string>;
 
-declare const crypto_generateSHA256Hash: typeof generateSHA256Hash;
-declare namespace crypto {
-  export { crypto_generateSHA256Hash as generateSHA256Hash };
-}
-
 /**
  * Deeply merges a partial update into a target object
  * @param target The complete target object
@@ -1845,11 +1550,6 @@ declare namespace crypto {
  */
 declare function deepMerge<T extends object>(target: T, update: Partial<T>): T;
 
-declare const merge_deepMerge: typeof deepMerge;
-declare namespace merge {
-  export { merge_deepMerge as deepMerge };
-}
-
 /**
  * Converts a schema definition into TypeScript type definitions
  * @param schema - The schema definition
@@ -1857,11 +1557,6 @@ declare namespace merge {
  */
 declare function schemaToTypes(schema: SchemaDefinition): string;
 
-declare const typegen_schemaToTypes: typeof schemaToTypes;
-declare namespace typegen {
-  export { schemaToTypes as default, typegen_schemaToTypes as schemaToTypes };
-}
-
 /**
  * Creates a Standard Schema validator that conforms to the StandardSchemaV1 interface.
  * The validator uses a closure pattern to maintain internal state and avoid prop drilling.
@@ -1881,11 +1576,6 @@ declare namespace typegen {
  */
 declare function createStandardSchemaValidator<T extends Record<string, any>>(schema: SchemaDefinition, constraintsMap: PredicateMap): StandardSchemaV1<T, T>;
 
-declare const validator_createStandardSchemaValidator: typeof createStandardSchemaValidator;
-declare namespace validator {
-  export { validator_createStandardSchemaValidator as createStandardSchemaValidator };
-}
-
 /**
  * Calculates the next version number based on schema changes.
  * @param currentVersion - Current semantic version string
@@ -1910,11 +1600,4 @@ declare function compareSemanticVersions(a: string, b: string): number;
  */
 declare function sortSemanticVars(vars: string[]): string[];
 
-declare const version_calculateNextVersion: typeof calculateNextVersion;
-declare const version_compareSemanticVersions: typeof compareSemanticVersions;
-declare const version_sortSemanticVars: typeof sortSemanticVars;
-declare namespace version {
-  export { version_calculateNextVersion as calculateNextVersion, version_compareSemanticVersions as compareSemanticVersions, version_sortSemanticVars as sortSemanticVars };
-}
-
-export { migrations as MigrationTypes, persistence as PersistenceTypes, registry as RegistryType, schemaDefinition as SchemaTypes, crypto, merge, index$1 as migration, patch, index$3 as persistence, index$2 as registry, index as schema, typegen, validator, version };
+export { type Constraint, type ConstraintGroup, type ConstraintParameters, type ConstraintsMap, type DataTransform, type FieldDefinition, type FieldType, type FunctionMap, type IndexDefinition, type IndexType, JsonPatchError, type LogicalOperator, type Migration, type MigrationEngine, MigrationError, MigrationErrorCode, type MigrationMetadata, MigrationSchema, type PartialIndexCondition, type PatchOperation, type Persistence, type PersistenceCollection, type PersistenceEvent, type PersistenceEventType, type PersistenceTransaction, type Predicate, type PredicateMap, type PredicateName, type PredicateParameters, type RegistryLock, type RegistryMetadata, type SchemaChange, type SchemaConstraint, type SchemaDefinition, type SchemaIndex, type SchemaMetadata, type SchemaRegistry, type SchemaVersion, type TransformFunction, applyPatch, calculateNextVersion, compareSemanticVersions, createPatch, createSchemaMigrationHelper, createStandardSchemaValidator, deepMerge, generateSHA256Hash, normalizePath, schemaChangeToPatch, schemaToTypes, sortSemanticVars, validate, validateMigration, validateSchemaChange, validateSchemaDefinition };