@procedures/client 0.0.0-stage → 0.2.0

package/dist/collections/storage/memory.d.ts

@@ -0,0 +1,68 @@
+/**
+ * In-Memory Storage Implementation
+ *
+ * Fast, volatile storage using JavaScript Map.
+ * All operations return Promises for interface consistency.
+ */
+import type { CollectionStorage, StorageMetadata } from "./interface.js";
+/**
+ * In-memory storage backed by JavaScript Map.
+ *
+ * Features:
+ * - Fast lookups O(1)
+ * - No persistence (data lost on restart)
+ * - Memory-bound (limited by available RAM)
+ * - Returns Promises for API consistency with remote storage
+ *
+ * @example
+ * ```typescript
+ * const storage = new InMemoryStorage<User>();
+ * await storage.set("123", { id: "123", name: "John" });
+ * const user = await storage.get("123"); // { id: "123", name: "John" }
+ * ```
+ */
+export declare class InMemoryStorage<T> implements CollectionStorage<T> {
+    private data;
+    get(id: string): Promise<T | undefined>;
+    getAll(): Promise<T[]>;
+    find(predicate: (item: T) => boolean): Promise<T[]>;
+    has(id: string): Promise<boolean>;
+    size(): Promise<number>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    setBatch(items: Array<[string, T]>): Promise<void>;
+    deleteBatch(ids: string[]): Promise<number>;
+    getBatch(ids: string[]): Promise<Map<string, T>>;
+    close(): Promise<void>;
+    getMetadata(): Promise<StorageMetadata>;
+    /**
+     * Get all keys in storage.
+     *
+     * @returns Iterator of keys
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Get all values in storage.
+     *
+     * @returns Iterator of values
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Get all entries in storage.
+     *
+     * @returns Iterator of [id, value] tuples
+     */
+    entries(): IterableIterator<[string, T]>;
+    /**
+     * Iterate over storage entries.
+     *
+     * @param callback - Function to call for each entry
+     */
+    forEach(callback: (value: T, key: string, map: Map<string, T>) => void): void;
+    /**
+     * Make storage iterable.
+     */
+    [Symbol.iterator](): IterableIterator<[string, T]>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/collections/storage/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/collections/storage/memory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEzE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,YAAW,iBAAiB,CAAC,CAAC,CAAC;IAC7D,OAAO,CAAC,IAAI,CAAwB;IAMpC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAIvC,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAItB,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAUnD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAQvB,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxC,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAStB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOlD,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAU3C,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAehD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC;IAmBvC;;;;OAIG;IACH,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIhC;;;;OAIG;IACH,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI7B;;;;OAIG;IACH,OAAO,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAIxC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAI7E;;OAEG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAGnD"}

package/dist/collections/storage/memory.js

@@ -0,0 +1,154 @@
+/**
+ * In-Memory Storage Implementation
+ *
+ * Fast, volatile storage using JavaScript Map.
+ * All operations return Promises for interface consistency.
+ */
+/**
+ * In-memory storage backed by JavaScript Map.
+ *
+ * Features:
+ * - Fast lookups O(1)
+ * - No persistence (data lost on restart)
+ * - Memory-bound (limited by available RAM)
+ * - Returns Promises for API consistency with remote storage
+ *
+ * @example
+ * ```typescript
+ * const storage = new InMemoryStorage<User>();
+ * await storage.set("123", { id: "123", name: "John" });
+ * const user = await storage.get("123"); // { id: "123", name: "John" }
+ * ```
+ */
+export class InMemoryStorage {
+    data = new Map();
+    //
+    // ═══ Read Operations ═══
+    //
+    get(id) {
+        return Promise.resolve(this.data.get(id));
+    }
+    getAll() {
+        return Promise.resolve(Array.from(this.data.values()));
+    }
+    find(predicate) {
+        const results = [];
+        for (const item of this.data.values()) {
+            if (predicate(item)) {
+                results.push(item);
+            }
+        }
+        return Promise.resolve(results);
+    }
+    has(id) {
+        return Promise.resolve(this.data.has(id));
+    }
+    size() {
+        return Promise.resolve(this.data.size);
+    }
+    //
+    // ═══ Write Operations ═══
+    //
+    set(id, value) {
+        this.data.set(id, value);
+        return Promise.resolve();
+    }
+    delete(id) {
+        return Promise.resolve(this.data.delete(id));
+    }
+    clear() {
+        this.data.clear();
+        return Promise.resolve();
+    }
+    //
+    // ═══ Bulk Operations ═══
+    //
+    setBatch(items) {
+        for (const [id, value] of items) {
+            this.data.set(id, value);
+        }
+        return Promise.resolve();
+    }
+    deleteBatch(ids) {
+        let deleted = 0;
+        for (const id of ids) {
+            if (this.data.delete(id)) {
+                deleted++;
+            }
+        }
+        return Promise.resolve(deleted);
+    }
+    getBatch(ids) {
+        const result = new Map();
+        for (const id of ids) {
+            const value = this.data.get(id);
+            if (value !== undefined) {
+                result.set(id, value);
+            }
+        }
+        return Promise.resolve(result);
+    }
+    //
+    // ═══ Lifecycle & Metadata ═══
+    //
+    close() {
+        // No cleanup needed for in-memory storage
+        this.data.clear();
+        return Promise.resolve();
+    }
+    getMetadata() {
+        // Rough memory estimation:
+        // Each entry has ~overhead of 100 bytes (key string + Map entry overhead)
+        const estimatedEntrySize = 100;
+        const memoryUsage = this.data.size * estimatedEntrySize;
+        return Promise.resolve({
+            type: "memory",
+            size: this.data.size,
+            stats: {
+                memoryUsage,
+            },
+        });
+    }
+    //
+    // ═══ Additional Methods (Map compatibility) ═══
+    //
+    /**
+     * Get all keys in storage.
+     *
+     * @returns Iterator of keys
+     */
+    keys() {
+        return this.data.keys();
+    }
+    /**
+     * Get all values in storage.
+     *
+     * @returns Iterator of values
+     */
+    values() {
+        return this.data.values();
+    }
+    /**
+     * Get all entries in storage.
+     *
+     * @returns Iterator of [id, value] tuples
+     */
+    entries() {
+        return this.data.entries();
+    }
+    /**
+     * Iterate over storage entries.
+     *
+     * @param callback - Function to call for each entry
+     */
+    forEach(callback) {
+        this.data.forEach(callback);
+    }
+    /**
+     * Make storage iterable.
+     */
+    [Symbol.iterator]() {
+        return this.data.entries();
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/collections/storage/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/collections/storage/memory.ts"],"names":[],"mappings":"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"}

package/dist/collections/utils/defaults.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Default implementations of equality, hashing, and comparison functions.
+ *
+ * Provides sensible defaults for primitive types and utilities for
+ * creating custom comparators.
+ */
+import type { Eq, Hash, Compare } from "../core/traits.js";
+/**
+ * Default equality using strict equality (===).
+ * Works for primitives and reference equality for objects.
+ */
+export declare const defaultEq: Eq<any>;
+/**
+ * Structural equality for objects (shallow comparison of properties).
+ * Compares own enumerable properties using ===.
+ */
+export declare const shallowEq: Eq<any>;
+/**
+ * Deep structural equality (recursive comparison).
+ * Handles nested objects and arrays.
+ */
+export declare const deepEq: Eq<any>;
+/**
+ * Equality by comparing a specific property.
+ *
+ * @example
+ * const userEq = eqBy<User, 'id'>('id')
+ * // or with accessor function:
+ * const userEq = eqBy<User>((u) => u.id)
+ */
+export declare const eqBy: <T, K extends keyof T = keyof T>(keyOrFn: K | ((value: T) => any)) => Eq<T>;
+/**
+ * Default hash function for primitives and objects.
+ * For objects, hashes the JSON string representation.
+ */
+export declare const defaultHash: Hash<any>;
+/**
+ * Hash function for strings using djb2 algorithm.
+ */
+export declare const hashString: (str: string) => number;
+/**
+ * Hash function for numbers.
+ */
+export declare const hashNumber: (num: number) => number;
+/**
+ * Combine multiple hash values.
+ * Useful for hashing objects with multiple fields.
+ *
+ * @example
+ * const pointHash: Hash<Point> = (p) =>
+ *   combineHashes(hashNumber(p.x), hashNumber(p.y))
+ */
+export declare const combineHashes: (...hashes: number[]) => number;
+/**
+ * Create a hash function that hashes by a specific property.
+ *
+ * @example
+ * const userHash = hashBy<User>((u) => u.id)
+ */
+export declare const hashBy: <T>(accessor: (value: T) => any) => Hash<T>;
+/**
+ * Natural ordering comparison for primitives.
+ * Numbers, strings, booleans, dates are compared naturally.
+ */
+export declare const defaultCompare: Compare<any>;
+/**
+ * Numeric comparison (for numbers).
+ */
+export declare const numberCompare: Compare<number>;
+/**
+ * String comparison using locale-aware sorting.
+ */
+export declare const stringCompare: Compare<string>;
+/**
+ * Case-insensitive string comparison.
+ */
+export declare const stringCompareIgnoreCase: Compare<string>;
+/**
+ * Date comparison.
+ */
+export declare const dateCompare: Compare<Date>;
+/**
+ * Boolean comparison (false < true).
+ */
+export declare const booleanCompare: Compare<boolean>;
+/**
+ * Reverses a comparator.
+ *
+ * @example
+ * const descending = reversed(numberCompare)
+ */
+export declare const reversed: <T>(compare: Compare<T>) => Compare<T>;
+/**
+ * Creates a comparator that compares by a specific property or function.
+ *
+ * @example
+ * const byAge = comparing<Person>((p) => p.age)
+ * const byName = comparing<Person, 'name'>('name')
+ */
+export declare const comparing: <T, K extends keyof T = keyof T>(keyOrFn: K | ((value: T) => any), compare?: Compare<any>) => Compare<T>;
+/**
+ * Chains comparators. If the first comparator returns 0 (equal),
+ * tries the next comparator, and so on.
+ *
+ * @example
+ * const userCompare = thenComparing(
+ *   comparing<User>('lastName'),
+ *   comparing<User>('firstName'),
+ *   comparing<User>('age')
+ * )
+ */
+export declare const thenComparing: <T>(...comparators: Compare<T>[]) => Compare<T>;
+/**
+ * Creates a comparator that treats null/undefined as less than all other values.
+ *
+ * @example
+ * const compare = nullsFirst(numberCompare)
+ */
+export declare const nullsFirst: <T>(compare: Compare<T>) => Compare<T | null | undefined>;
+/**
+ * Creates a comparator that treats null/undefined as greater than all other values.
+ *
+ * @example
+ * const compare = nullsLast(numberCompare)
+ */
+export declare const nullsLast: <T>(compare: Compare<T>) => Compare<T | null | undefined>;
+/**
+ * Creates a comparator from a key extraction function.
+ * Elements are compared by their extracted keys.
+ *
+ * @example
+ * const byLength = comparingKey<string>((s) => s.length)
+ */
+export declare const comparingKey: <T, K>(keyExtractor: (value: T) => K, keyCompare?: Compare<K>) => Compare<T>;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/collections/utils/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/collections/utils/defaults.ts"],"names":[],"mappings":"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"}

package/dist/collections/utils/defaults.js

@@ -0,0 +1,322 @@
+/**
+ * Default implementations of equality, hashing, and comparison functions.
+ *
+ * Provides sensible defaults for primitive types and utilities for
+ * creating custom comparators.
+ */
+// ============================================================================
+// Default Equality
+// ============================================================================
+/**
+ * Default equality using strict equality (===).
+ * Works for primitives and reference equality for objects.
+ */
+export const defaultEq = (a, b) => a === b;
+/**
+ * Structural equality for objects (shallow comparison of properties).
+ * Compares own enumerable properties using ===.
+ */
+export const shallowEq = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    if (a === null || b === null)
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key))
+            return false;
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+};
+/**
+ * Deep structural equality (recursive comparison).
+ * Handles nested objects and arrays.
+ */
+export const deepEq = (a, b) => {
+    if (a === b)
+        return true;
+    if (typeof a !== typeof b)
+        return false;
+    if (typeof a !== "object" || a === null || b === null)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEq(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key))
+            return false;
+        if (!deepEq(a[key], b[key]))
+            return false;
+    }
+    return true;
+};
+/**
+ * Equality by comparing a specific property.
+ *
+ * @example
+ * const userEq = eqBy<User, 'id'>('id')
+ * // or with accessor function:
+ * const userEq = eqBy<User>((u) => u.id)
+ */
+export const eqBy = (keyOrFn) => {
+    const accessor = typeof keyOrFn === "function" ? keyOrFn : (v) => v[keyOrFn];
+    return (a, b) => accessor(a) === accessor(b);
+};
+// ============================================================================
+// Default Hashing
+// ============================================================================
+/**
+ * Default hash function for primitives and objects.
+ * For objects, hashes the JSON string representation.
+ */
+export const defaultHash = (value) => {
+    if (value === null)
+        return 0;
+    if (value === undefined)
+        return 1;
+    const type = typeof value;
+    switch (type) {
+        case "boolean":
+            return value ? 1 : 0;
+        case "number":
+            return hashNumber(value);
+        case "string":
+            return hashString(value);
+        case "symbol":
+            return hashString(value.toString());
+        case "bigint":
+            return hashString(value.toString());
+        case "object":
+            // For objects, hash their JSON representation
+            // This is not ideal for all cases but provides a reasonable default
+            try {
+                return hashString(JSON.stringify(value));
+            }
+            catch {
+                // If JSON.stringify fails, fall back to toString
+                return hashString(value.toString());
+            }
+        default:
+            return 2;
+    }
+};
+/**
+ * Hash function for strings using djb2 algorithm.
+ */
+export const hashString = (str) => {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash) + str.charCodeAt(i); // hash * 33 + c
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return hash >>> 0; // Convert to unsigned
+};
+/**
+ * Hash function for numbers.
+ */
+export const hashNumber = (num) => {
+    if (Number.isNaN(num))
+        return 0;
+    if (!Number.isFinite(num))
+        return num > 0 ? 1 : -1;
+    // For integers, use the number itself
+    if (Number.isInteger(num)) {
+        return num | 0; // Convert to 32-bit int
+    }
+    // For floats, hash the string representation
+    return hashString(num.toString());
+};
+/**
+ * Combine multiple hash values.
+ * Useful for hashing objects with multiple fields.
+ *
+ * @example
+ * const pointHash: Hash<Point> = (p) =>
+ *   combineHashes(hashNumber(p.x), hashNumber(p.y))
+ */
+export const combineHashes = (...hashes) => {
+    let combined = 0;
+    for (const hash of hashes) {
+        combined = ((combined << 5) - combined) + hash;
+        combined = combined & combined; // Convert to 32-bit int
+    }
+    return combined >>> 0; // Convert to unsigned
+};
+/**
+ * Create a hash function that hashes by a specific property.
+ *
+ * @example
+ * const userHash = hashBy<User>((u) => u.id)
+ */
+export const hashBy = (accessor) => {
+    return (value) => defaultHash(accessor(value));
+};
+// ============================================================================
+// Default Comparison
+// ============================================================================
+/**
+ * Natural ordering comparison for primitives.
+ * Numbers, strings, booleans, dates are compared naturally.
+ */
+export const defaultCompare = (a, b) => {
+    if (a === b)
+        return 0;
+    if (a === null || a === undefined)
+        return -1;
+    if (b === null || b === undefined)
+        return 1;
+    // Handle dates
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() - b.getTime();
+    }
+    // Handle numbers
+    if (typeof a === "number" && typeof b === "number") {
+        if (Number.isNaN(a))
+            return Number.isNaN(b) ? 0 : -1;
+        if (Number.isNaN(b))
+            return 1;
+        return a - b;
+    }
+    // Handle strings
+    if (typeof a === "string" && typeof b === "string") {
+        return a.localeCompare(b);
+    }
+    // Handle booleans
+    if (typeof a === "boolean" && typeof b === "boolean") {
+        return a === b ? 0 : a ? 1 : -1;
+    }
+    // Fallback: convert to string and compare
+    return String(a).localeCompare(String(b));
+};
+/**
+ * Numeric comparison (for numbers).
+ */
+export const numberCompare = (a, b) => {
+    if (Number.isNaN(a))
+        return Number.isNaN(b) ? 0 : -1;
+    if (Number.isNaN(b))
+        return 1;
+    return a - b;
+};
+/**
+ * String comparison using locale-aware sorting.
+ */
+export const stringCompare = (a, b) => a.localeCompare(b);
+/**
+ * Case-insensitive string comparison.
+ */
+export const stringCompareIgnoreCase = (a, b) => a.toLowerCase().localeCompare(b.toLowerCase());
+/**
+ * Date comparison.
+ */
+export const dateCompare = (a, b) => a.getTime() - b.getTime();
+/**
+ * Boolean comparison (false < true).
+ */
+export const booleanCompare = (a, b) => a === b ? 0 : a ? 1 : -1;
+// ============================================================================
+// Comparator Combinators
+// ============================================================================
+/**
+ * Reverses a comparator.
+ *
+ * @example
+ * const descending = reversed(numberCompare)
+ */
+export const reversed = (compare) => (a, b) => compare(b, a);
+/**
+ * Creates a comparator that compares by a specific property or function.
+ *
+ * @example
+ * const byAge = comparing<Person>((p) => p.age)
+ * const byName = comparing<Person, 'name'>('name')
+ */
+export const comparing = (keyOrFn, compare = defaultCompare) => {
+    const accessor = typeof keyOrFn === "function" ? keyOrFn : (v) => v[keyOrFn];
+    return (a, b) => compare(accessor(a), accessor(b));
+};
+/**
+ * Chains comparators. If the first comparator returns 0 (equal),
+ * tries the next comparator, and so on.
+ *
+ * @example
+ * const userCompare = thenComparing(
+ *   comparing<User>('lastName'),
+ *   comparing<User>('firstName'),
+ *   comparing<User>('age')
+ * )
+ */
+export const thenComparing = (...comparators) => {
+    return (a, b) => {
+        for (const compare of comparators) {
+            const result = compare(a, b);
+            if (result !== 0)
+                return result;
+        }
+        return 0;
+    };
+};
+/**
+ * Creates a comparator that treats null/undefined as less than all other values.
+ *
+ * @example
+ * const compare = nullsFirst(numberCompare)
+ */
+export const nullsFirst = (compare) => {
+    return (a, b) => {
+        if (a == null && b == null)
+            return 0;
+        if (a == null)
+            return -1;
+        if (b == null)
+            return 1;
+        return compare(a, b);
+    };
+};
+/**
+ * Creates a comparator that treats null/undefined as greater than all other values.
+ *
+ * @example
+ * const compare = nullsLast(numberCompare)
+ */
+export const nullsLast = (compare) => {
+    return (a, b) => {
+        if (a == null && b == null)
+            return 0;
+        if (a == null)
+            return 1;
+        if (b == null)
+            return -1;
+        return compare(a, b);
+    };
+};
+/**
+ * Creates a comparator from a key extraction function.
+ * Elements are compared by their extracted keys.
+ *
+ * @example
+ * const byLength = comparingKey<string>((s) => s.length)
+ */
+export const comparingKey = (keyExtractor, keyCompare = defaultCompare) => {
+    return (a, b) => keyCompare(keyExtractor(a), keyExtractor(b));
+};
+//# sourceMappingURL=defaults.js.map