@lossless.org/client 0.1.0

package/dist_ts/objectstorage/classes.watcher.js

@@ -0,0 +1,249 @@
+// classes.watcher.ts
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+import { EventEmitter } from 'node:events';
+/**
+ * BucketWatcher monitors a storage bucket for changes (add/modify/delete)
+ * using a polling-based approach. Designed to follow the SmartdataDbWatcher pattern.
+ *
+ * @example
+ * ```typescript
+ * const watcher = bucket.createWatcher({ prefix: 'uploads/', pollIntervalMs: 3000 });
+ *
+ * // RxJS Observable pattern
+ * watcher.changeSubject.subscribe((change) => {
+ *   console.log('Change:', change);
+ * });
+ *
+ * // EventEmitter pattern
+ * watcher.on('change', (change) => console.log(change));
+ * watcher.on('error', (err) => console.error(err));
+ *
+ * await watcher.start();
+ * await watcher.readyDeferred.promise; // Wait for initial state
+ *
+ * // Later...
+ * await watcher.stop();
+ * ```
+ */
+export class BucketWatcher extends EventEmitter {
+    /** Deferred that resolves when initial state is built and watcher is ready */
+    readyDeferred = plugins.smartpromise.defer();
+    /** Observable for receiving change events (supports RxJS operators) */
+    changeSubject;
+    // Internal subjects and state
+    rawSubject;
+    previousState;
+    pollIntervalId = null;
+    isPolling = false;
+    isStopped = false;
+    // Configuration
+    bucketRef;
+    prefix;
+    pollIntervalMs;
+    bufferTimeMs;
+    includeInitial;
+    pageSize;
+    constructor(bucketRef, options = {}) {
+        super();
+        this.bucketRef = bucketRef;
+        this.prefix = options.prefix ?? '';
+        this.pollIntervalMs = options.pollIntervalMs ?? 5000;
+        this.bufferTimeMs = options.bufferTimeMs;
+        this.includeInitial = options.includeInitial ?? false;
+        this.pageSize = options.pageSize ?? 1000;
+        // Initialize state tracking
+        this.previousState = new Map();
+        // Initialize raw subject for emitting changes
+        this.rawSubject = new plugins.smartrx.rxjs.Subject();
+        // Configure the public observable with optional buffering
+        if (this.bufferTimeMs && this.bufferTimeMs > 0) {
+            this.changeSubject = this.rawSubject.pipe(plugins.smartrx.rxjs.ops.bufferTime(this.bufferTimeMs), plugins.smartrx.rxjs.ops.filter((events) => events.length > 0));
+        }
+        else {
+            this.changeSubject = this.rawSubject.asObservable();
+        }
+    }
+    /**
+     * Start watching the bucket for changes
+     */
+    async start() {
+        if (this.pollIntervalId !== null) {
+            console.log('BucketWatcher is already running');
+            return;
+        }
+        this.isStopped = false;
+        // Build initial state
+        await this.buildInitialState();
+        // Emit initial state as 'add' events if configured
+        if (this.includeInitial) {
+            for (const state of this.previousState.values()) {
+                this.emitChange({
+                    type: 'add',
+                    key: state.key,
+                    size: state.size,
+                    etag: state.etag,
+                    lastModified: state.lastModified,
+                    bucket: this.bucketRef.name,
+                });
+            }
+        }
+        // Mark as ready
+        this.readyDeferred.resolve();
+        // Start polling loop
+        this.pollIntervalId = setInterval(() => {
+            this.poll().catch((err) => {
+                this.emit('error', err);
+            });
+        }, this.pollIntervalMs);
+    }
+    /**
+     * Stop watching the bucket
+     */
+    async stop() {
+        this.isStopped = true;
+        if (this.pollIntervalId !== null) {
+            clearInterval(this.pollIntervalId);
+            this.pollIntervalId = null;
+        }
+        // Wait for any in-progress poll to complete
+        while (this.isPolling) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        this.rawSubject.complete();
+    }
+    /**
+     * Alias for stop() - for consistency with other APIs
+     */
+    async close() {
+        return this.stop();
+    }
+    /**
+     * Build the initial state by listing all objects with metadata
+     */
+    async buildInitialState() {
+        this.previousState.clear();
+        for await (const obj of this.listObjectsWithMetadata()) {
+            if (obj.Key) {
+                this.previousState.set(obj.Key, {
+                    key: obj.Key,
+                    etag: obj.ETag ?? '',
+                    size: obj.Size ?? 0,
+                    lastModified: obj.LastModified ?? new Date(0),
+                });
+            }
+        }
+    }
+    /**
+     * Poll for changes by comparing current state against previous state
+     */
+    async poll() {
+        // Guard against overlapping polls
+        if (this.isPolling || this.isStopped) {
+            return;
+        }
+        this.isPolling = true;
+        try {
+            // Build current state
+            const currentState = new Map();
+            for await (const obj of this.listObjectsWithMetadata()) {
+                if (this.isStopped) {
+                    break;
+                }
+                if (obj.Key) {
+                    currentState.set(obj.Key, {
+                        key: obj.Key,
+                        etag: obj.ETag ?? '',
+                        size: obj.Size ?? 0,
+                        lastModified: obj.LastModified ?? new Date(0),
+                    });
+                }
+            }
+            if (!this.isStopped) {
+                this.detectChanges(currentState);
+                this.previousState = currentState;
+            }
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+        finally {
+            this.isPolling = false;
+        }
+    }
+    /**
+     * Detect changes between current and previous state
+     */
+    detectChanges(currentState) {
+        // Detect added and modified objects
+        for (const [key, current] of currentState) {
+            const previous = this.previousState.get(key);
+            if (!previous) {
+                // New object - emit 'add' event
+                this.emitChange({
+                    type: 'add',
+                    key: current.key,
+                    size: current.size,
+                    etag: current.etag,
+                    lastModified: current.lastModified,
+                    bucket: this.bucketRef.name,
+                });
+            }
+            else if (previous.etag !== current.etag ||
+                previous.size !== current.size ||
+                previous.lastModified.getTime() !== current.lastModified.getTime()) {
+                // Object modified - emit 'modify' event
+                this.emitChange({
+                    type: 'modify',
+                    key: current.key,
+                    size: current.size,
+                    etag: current.etag,
+                    lastModified: current.lastModified,
+                    bucket: this.bucketRef.name,
+                });
+            }
+        }
+        // Detect deleted objects
+        for (const [key, previous] of this.previousState) {
+            if (!currentState.has(key)) {
+                // Object deleted - emit 'delete' event
+                this.emitChange({
+                    type: 'delete',
+                    key: previous.key,
+                    bucket: this.bucketRef.name,
+                });
+            }
+        }
+    }
+    /**
+     * Emit a change event via both RxJS Subject and EventEmitter
+     */
+    emitChange(event) {
+        this.rawSubject.next(event);
+        this.emit('change', event);
+    }
+    /**
+     * List objects with full metadata (ETag, Size, LastModified)
+     * This is a private method that yields full _Object data, not just keys
+     */
+    async *listObjectsWithMetadata() {
+        let continuationToken;
+        do {
+            if (this.isStopped) {
+                return;
+            }
+            const command = new plugins.s3.ListObjectsV2Command({
+                Bucket: this.bucketRef.name,
+                Prefix: this.prefix,
+                MaxKeys: this.pageSize,
+                ContinuationToken: continuationToken,
+            });
+            const response = await this.bucketRef.smartbucketRef.storageClient.send(command);
+            for (const obj of response.Contents || []) {
+                yield obj;
+            }
+            continuationToken = response.NextContinuationToken;
+        } while (continuationToken);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.watcher.js","sourceRoot":"","sources":["../../ts/objectstorage/classes.watcher.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/helpers.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+export declare const reducePathDescriptorToPath: (pathDescriptorArg: interfaces.IPathDecriptor) => Promise<string>;
+export interface IStorageWarning {
+    code: string;
+    message: string;
+}
+export interface INormalizedStorageConfig {
+    endpointUrl: string;
+    host: string;
+    protocol: 'http' | 'https';
+    port?: number;
+    region: string;
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    forcePathStyle: boolean;
+}
+export declare function normalizeStorageDescriptor(input: plugins.tsclass.storage.IStorageDescriptor, logger?: {
+    warn: (msg: string) => void;
+}): {
+    normalized: INormalizedStorageConfig;
+    warnings: IStorageWarning[];
+};

package/dist_ts/objectstorage/helpers.js

@@ -0,0 +1,215 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces.js';
+export const reducePathDescriptorToPath = async (pathDescriptorArg) => {
+    let returnPath = ``;
+    if (pathDescriptorArg.directory) {
+        if (pathDescriptorArg.path && plugins.path.isAbsolute(pathDescriptorArg.path)) {
+            console.warn('Directory is being ignored when path is absolute.');
+            returnPath = pathDescriptorArg.path;
+        }
+        else if (pathDescriptorArg.path) {
+            returnPath = plugins.path.join(pathDescriptorArg.directory.getBasePath(), pathDescriptorArg.path);
+        }
+    }
+    else if (pathDescriptorArg.path) {
+        returnPath = pathDescriptorArg.path;
+    }
+    else {
+        throw new Error('You must specify either a path or a directory.');
+    }
+    if (returnPath.startsWith('/')) {
+        returnPath = returnPath.substring(1);
+    }
+    return returnPath;
+};
+function coerceBooleanMaybe(value) {
+    if (typeof value === 'boolean')
+        return { value };
+    if (typeof value === 'string') {
+        const v = value.trim().toLowerCase();
+        if (v === 'true' || v === '1') {
+            return {
+                value: true,
+                warning: {
+                    code: 'SBK_S3_COERCED_USESSL',
+                    message: `Coerced useSsl='${value}' (string) to boolean true.`
+                }
+            };
+        }
+        if (v === 'false' || v === '0') {
+            return {
+                value: false,
+                warning: {
+                    code: 'SBK_S3_COERCED_USESSL',
+                    message: `Coerced useSsl='${value}' (string) to boolean false.`
+                }
+            };
+        }
+    }
+    return { value: undefined };
+}
+function coercePortMaybe(port) {
+    if (port === undefined || port === null || port === '')
+        return { value: undefined };
+    const n = typeof port === 'number' ? port : Number(String(port).trim());
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0 || n > 65535) {
+        return {
+            value: undefined,
+            warning: {
+                code: 'SBK_S3_INVALID_PORT',
+                message: `Invalid port '${String(port)}' - expected integer in [1..65535].`
+            }
+        };
+    }
+    return { value: n };
+}
+function sanitizeEndpointString(raw) {
+    const warnings = [];
+    let s = String(raw ?? '').trim();
+    if (s !== String(raw ?? '')) {
+        warnings.push({
+            code: 'SBK_S3_TRIMMED_ENDPOINT',
+            message: 'Trimmed surrounding whitespace from endpoint.'
+        });
+    }
+    return { value: s, warnings };
+}
+function parseEndpointHostPort(endpoint, provisionalProtocol) {
+    let url;
+    const extras = {};
+    // Check if endpoint already has a scheme
+    const hasScheme = /^https?:\/\//i.test(endpoint);
+    // Try parsing as full URL first
+    try {
+        if (hasScheme) {
+            url = new URL(endpoint);
+        }
+        else {
+            // Not a full URL; try host[:port] by attaching provisional scheme
+            // Remove anything after first '/' for safety
+            const cleanEndpoint = endpoint.replace(/\/.*/, '');
+            url = new URL(`${provisionalProtocol}://${cleanEndpoint}`);
+        }
+    }
+    catch (e) {
+        throw new Error(`Unable to parse endpoint '${endpoint}'.`);
+    }
+    // Check for dropped components
+    if (url.username || url.password)
+        extras.droppedCreds = true;
+    if (url.pathname && url.pathname !== '/')
+        extras.droppedPath = true;
+    if (url.search)
+        extras.droppedQuery = true;
+    const hadScheme = hasScheme;
+    const host = url.hostname; // hostnames lowercased by URL; IPs preserved
+    const port = url.port ? Number(url.port) : undefined;
+    return { hadScheme, host, port, extras };
+}
+export function normalizeStorageDescriptor(input, logger) {
+    const warnings = [];
+    const logWarn = (w) => {
+        warnings.push(w);
+        if (logger) {
+            logger.warn(`[SmartBucket] ${w.code}: ${w.message}`);
+        }
+        else {
+            console.warn(`[SmartBucket] ${w.code}: ${w.message}`);
+        }
+    };
+    // Coerce and sanitize inputs
+    const { value: coercedUseSsl, warning: useSslWarn } = coerceBooleanMaybe(input.useSsl);
+    if (useSslWarn)
+        logWarn(useSslWarn);
+    const { value: coercedPort, warning: portWarn } = coercePortMaybe(input.port);
+    if (portWarn)
+        logWarn(portWarn);
+    const { value: endpointStr, warnings: endpointSanWarnings } = sanitizeEndpointString(input.endpoint);
+    endpointSanWarnings.forEach(logWarn);
+    if (!endpointStr) {
+        throw new Error('Storage endpoint is required (got empty string). Provide hostname or URL.');
+    }
+    // Provisional protocol selection for parsing host:port forms
+    const provisionalProtocol = coercedUseSsl === false ? 'http' : 'https';
+    const { hadScheme, host, port: epPort, extras } = parseEndpointHostPort(endpointStr, provisionalProtocol);
+    if (extras.droppedCreds) {
+        logWarn({
+            code: 'SBK_S3_DROPPED_CREDENTIALS',
+            message: 'Ignored credentials in endpoint URL.'
+        });
+    }
+    if (extras.droppedPath) {
+        logWarn({
+            code: 'SBK_S3_DROPPED_PATH',
+            message: 'Removed path segment from endpoint URL; S3 endpoint should be host[:port] only.'
+        });
+    }
+    if (extras.droppedQuery) {
+        logWarn({
+            code: 'SBK_S3_DROPPED_QUERY',
+            message: 'Removed query string from endpoint URL; S3 endpoint should be host[:port] only.'
+        });
+    }
+    // Final protocol decision
+    let finalProtocol;
+    if (hadScheme) {
+        // Scheme from endpoint wins
+        const schemeFromEndpoint = endpointStr.trim().toLowerCase().startsWith('http://') ? 'http' : 'https';
+        finalProtocol = schemeFromEndpoint;
+        if (typeof coercedUseSsl === 'boolean') {
+            const expected = coercedUseSsl ? 'https' : 'http';
+            if (expected !== finalProtocol) {
+                logWarn({
+                    code: 'SBK_S3_SCHEME_CONFLICT',
+                    message: `useSsl=${String(coercedUseSsl)} conflicts with endpoint scheme '${finalProtocol}'; using endpoint scheme.`
+                });
+            }
+        }
+    }
+    else {
+        if (typeof coercedUseSsl === 'boolean') {
+            finalProtocol = coercedUseSsl ? 'https' : 'http';
+        }
+        else {
+            finalProtocol = 'https';
+            logWarn({
+                code: 'SBK_S3_GUESSED_PROTOCOL',
+                message: "No scheme in endpoint and useSsl not provided; defaulting to 'https'."
+            });
+        }
+    }
+    // Final port decision
+    let finalPort = undefined;
+    if (coercedPort !== undefined && epPort !== undefined && coercedPort !== epPort) {
+        logWarn({
+            code: 'SBK_S3_PORT_CONFLICT',
+            message: `Port in config (${coercedPort}) conflicts with endpoint port (${epPort}); using config port.`
+        });
+        finalPort = coercedPort;
+    }
+    else {
+        finalPort = (coercedPort !== undefined) ? coercedPort : epPort;
+    }
+    // Build canonical endpoint URL (origin only, no trailing slash)
+    const url = new URL(`${finalProtocol}://${host}`);
+    if (finalPort !== undefined)
+        url.port = String(finalPort);
+    const endpointUrl = url.origin;
+    const region = input.region || 'us-east-1';
+    return {
+        normalized: {
+            endpointUrl,
+            host,
+            protocol: finalProtocol,
+            port: finalPort,
+            region,
+            credentials: {
+                accessKeyId: input.accessKey,
+                secretAccessKey: input.accessSecret,
+            },
+            forcePathStyle: true,
+        },
+        warnings,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../ts/objectstorage/helpers.ts"],"names":[],"mappings":"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"}

package/dist_ts/objectstorage/index.d.ts

@@ -0,0 +1,13 @@
+export * from './classes.smartbucket.js';
+export * from './classes.bucket.js';
+export * from './classes.exactuploaderror.js';
+export * from './classes.exactpathpurgeerror.js';
+export * from './classes.directory.js';
+export * from './classes.file.js';
+export * from './classes.listcursor.js';
+export * from './classes.metadata.js';
+export * from './classes.trash.js';
+export * from './classes.watcher.js';
+export * from './interfaces.js';
+export { ObjectStorageConnection } from './classes.connection.js';
+export type { IObjectStorageConnectionOptions } from './classes.connection.js';

package/dist_ts/objectstorage/index.js

@@ -0,0 +1,13 @@
+export * from './classes.smartbucket.js';
+export * from './classes.bucket.js';
+export * from './classes.exactuploaderror.js';
+export * from './classes.exactpathpurgeerror.js';
+export * from './classes.directory.js';
+export * from './classes.file.js';
+export * from './classes.listcursor.js';
+export * from './classes.metadata.js';
+export * from './classes.trash.js';
+export * from './classes.watcher.js';
+export * from './interfaces.js';
+export { ObjectStorageConnection } from './classes.connection.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9vYmplY3RzdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9