euclid-ndk 0.2.0

package/dist/modules/esm.d.ts

@@ -0,0 +1,358 @@
+/**
+ * ESM - euclid's storage module: buckets, objects, attributes, subscriptions and transfers.
+ *
+ * One object, {@link EuclidEsm}, built from a session that has already logged in:
+ *
+ * ```ts
+ * const esm = (await Euclid.forServer(url).login("jens", "secret")).esm();
+ * const bucket = await esm.createBucket("reports");
+ * await esm.uploadFile(bucket.ern, "2026/q3.pdf", "q3.pdf");
+ * ```
+ *
+ * Most of what it does is the same JSON action every other module speaks. Four actions are not:
+ * `put-object`, `get-object`, `upload-part` and `download-part` carry the object's bytes themselves,
+ * with the bucket, the key and the part number riding as headers instead of in a body - which is what
+ * keeps a 5 MiB part 5 MiB on the wire rather than a third larger as base64 inside JSON.
+ *
+ * Those four also authenticate differently: they present the session's bearer token rather than a
+ * signature, which is what euclid-cli, euclid-jdk and euclid-pdk do for the same four actions, so
+ * every client writes objects the same way. A session that asked for `AUTH_SIGNATURE` signs
+ * them anyway - it asked not to be handed a token silently, and a signature over raw bytes is exact
+ * here in a way it is not in every language.
+ */
+import { type SubscribeResult, type Subscription, type Variant, type VariantInput } from "../dto/com.js";
+import { type BucketEvent, type CreateBucketResult, type DeleteObjectsResult, type DisableEncryptionResult, type EnableEncryptionResult, type EsmObject, type ObjectAttribute, type PurgeBucketResult, type RenameBucketResult, type SetBucketInternalResult, type StoredObject, type TouchObjectResult, type Bucket } from "../dto/esm.js";
+import { type Page } from "../dto/eam.js";
+import type { Response } from "../http/client.js";
+import { ModuleClient, type Bytes, type ListOptions } from "./base.js";
+import type { EuclidSession } from "./eam.js";
+export declare const TARGET = "esm";
+/** The object events a subscription can ask for. Asking for none asks for all of them. */
+export declare const OBJECT_CREATED = "esm.object.created";
+export declare const OBJECT_UPDATED = "esm.object.updated";
+export declare const OBJECT_DELETED = "esm.object.deleted";
+/**
+ * How much of a file goes into one part. Larger parts mean fewer round trips and more memory in
+ * flight; 5 MiB is what euclid-cli, euclid-jdk and euclid-pdk use, which is what makes a file
+ * uploaded by one of them arrive in the same pieces as one uploaded by another.
+ */
+export declare const DEFAULT_PART_SIZE: number;
+/** How many parts travel at once. */
+export declare const DEFAULT_CONCURRENCY = 4;
+/**
+ * How many attempts one step of a transfer gets. Transfers are long and made of many steps, so a
+ * transient failure in any of them would otherwise throw away everything already transferred.
+ */
+export declare const MAX_PART_ATTEMPTS = 4;
+/** The delay before retrying, in milliseconds, multiplied by the attempt number. */
+export declare const PART_RETRY_BASE_DELAY_MS = 500;
+/**
+ * What `get-object` answers when the object is at or above the size the caller said it would accept.
+ * Not an error in {@link EuclidEsm.downloadFile}: it is the server saying the object needs the
+ * multipart path.
+ */
+export declare const PAYLOAD_TOO_LARGE = 413;
+/** The actions that carry raw bytes rather than JSON - see this module's documentation. */
+export declare const BYTE_ACTIONS: string[];
+/** How a bucket listing is paged, and whether euclid's own buckets are in it. */
+export interface ListBucketsOptions extends ListOptions {
+    includeInternal?: boolean;
+}
+/** How an object listing is paged, and whether the directory markers are in it. */
+export interface ListObjectsOptions extends ListOptions {
+    includeDirectories?: boolean;
+}
+/**
+ * The two attribute maps a write carries, and they are not the same one.
+ *
+ * `attributes` are the caller's own, listed back by {@link EuclidEsm.listObjectAttributes} and
+ * meaningless to euclid. `systemAttributes` are euclid's envelope: they travel with the object across
+ * every hop and are never mixed into the caller's. The one euclid acts on is `priority` - an object
+ * written with `systemAttributes: { priority: PRIORITY_LOW }` produces a notification carrying it,
+ * which is how a producer's decision survives a hop through a bucket.
+ */
+export interface AttributeOptions {
+    attributes?: Record<string, VariantInput>;
+    systemAttributes?: Record<string, VariantInput>;
+}
+/** How a file is cut up on the way out, and what the object it becomes carries. */
+export interface UploadOptions extends AttributeOptions {
+    partSize?: number;
+    concurrency?: number;
+}
+/** How an object is fetched: in what parts, and how many at a time. */
+export interface DownloadOptions {
+    partSize?: number;
+    concurrency?: number;
+}
+/** Which of a bucket's events a subscription asks for, and which keys they have to match. */
+export interface SubscribeOptions {
+    /** {@link OBJECT_CREATED}, {@link OBJECT_UPDATED}, {@link OBJECT_DELETED}, or none for all. */
+    eventTypes?: Iterable<string>;
+    prefix?: string;
+    /** Whether the zero-byte directory markers are delivered too. */
+    directories?: boolean;
+}
+/** Which of a bucket's objects are re-announced, and whether the caller waits for it. */
+export interface TouchObjectOptions {
+    prefix?: string;
+    background?: boolean;
+}
+/**
+ * The notification a bucket subscription delivered, out of the message that carried it.
+ *
+ * A subscription puts its notification into a queue or a topic as an ordinary message, so nothing
+ * about receiving it is special - whatever reads that queue hands the message body to this.
+ *
+ * @throws {SyntaxError} if the body is not JSON at all.
+ */
+export declare function parseBucketEvent(messageBody: string | Buffer): BucketEvent;
+/**
+ * ESM's operations, on the credentials of the session that created it.
+ *
+ * Built by {@link EuclidSession.esm} rather than directly, so that it shares that session's identity,
+ * namespace and connection settings - and follows them as they change.
+ */
+export declare class EuclidEsm extends ModuleClient {
+    #private;
+    /**
+     * How long the byte-carrying actions may take, in milliseconds, or null for the session's own
+     * timeout. Worth raising: the session's default is sized for an action that answers from a
+     * database, and a 5 MiB part on a slow link is not that.
+     */
+    transferTimeoutMs: number | null;
+    /**
+     * The delay before one step of a transfer is tried again, multiplied by the attempt number.
+     *
+     * A field rather than a constant because it is the one thing about a retry a caller may reasonably
+     * want to change: nothing in a test suite wants to wait out a backoff that exists to be kind to a
+     * struggling server.
+     */
+    retryBaseDelayMs: number;
+    constructor(session: EuclidSession);
+    /**
+     * {@link parseBucketEvent}, reachable from the client so that the call that reads a subscription's
+     * messages is found next to the call that created the subscription.
+     */
+    static readonly parseBucketEvent: typeof parseBucketEvent;
+    /**
+     * Creates a bucket, and answers with the ERN everything else names it by.
+     *
+     * `internal` marks it as euclid's own plumbing rather than somebody's bucket, which leaves it out of
+     * an ordinary listing - see {@link setBucketInternal}, which is how a bucket that already exists
+     * changes its mind about that.
+     */
+    createBucket(name: string, internal?: boolean): Promise<CreateBucketResult>;
+    /** Deletes a bucket. It has to be empty; {@link purgeBucket} is what makes it so. */
+    deleteBucket(ern: string): Promise<void>;
+    /**
+     * One page of buckets, and how many exist in total.
+     *
+     * euclid's own buckets are left out unless `includeInternal` asks for them, so a listing shows what
+     * a person would recognise rather than the artifact bucket applications are deployed from.
+     */
+    listBuckets(options?: ListBucketsOptions): Promise<Page<Bucket>>;
+    /** The ERN of the bucket of this name, in the session's account and namespace. */
+    getBucketErn(name: string): Promise<string>;
+    /** How many bytes a bucket holds. */
+    getBucketSize(ern: string): Promise<number>;
+    /**
+     * Renames a bucket, and with it every object and subscription that named the old one.
+     *
+     * The ERN changes too, and nothing answers to the old one afterwards, so the one in the result is
+     * what later calls have to use. Refused rather than merged when a bucket of the new name exists.
+     */
+    renameBucket(ern: string, newName: string): Promise<RenameBucketResult>;
+    /**
+     * Marks a bucket as euclid's own plumbing, or stops doing so.
+     *
+     * Separate from creating one because the bucket this exists for usually predates anybody thinking
+     * about it, and reversible for the same reason: a flag that can only be set is one nobody dares set.
+     */
+    setBucketInternal(ern: string, internal?: boolean): Promise<SetBucketInternalResult>;
+    /**
+     * Deletes a bucket's objects, leaving the bucket itself in place.
+     *
+     * A prefix narrows it to the keys that start with that; an empty one purges everything.
+     */
+    purgeBucket(ern: string, prefix?: string): Promise<PurgeBucketResult>;
+    /**
+     * Encrypts every object written to this bucket from now on, under an EKM key.
+     *
+     * What it does not do is touch the objects already there: their bytes stay as they were stored, each
+     * one records the key it is under, and the result says how many such objects there are.
+     * Re-encrypting them is a decision for whoever owns the data.
+     *
+     * A named key has to exist and be usable for encryption. An unnamed one is created here as AES-256
+     * and belongs to EKM from that moment on - which means deleting it there is what makes this
+     * bucket's objects unrecoverable.
+     */
+    enableEncryption(bucketErn: string, keyId?: string): Promise<EnableEncryptionResult>;
+    /**
+     * Stops encrypting new objects written to a bucket.
+     *
+     * The mirror image of {@link enableEncryption} in one respect and no other: it says what happens to
+     * the next upload, and it is not an undo. Nothing already stored is decrypted or rewritten, and the
+     * key is left alone rather than revoked - those objects are still under it.
+     */
+    disableEncryption(bucketErn: string): Promise<DisableEncryptionResult>;
+    /** Tags a bucket. A key that is already tagged keeps its value - {@link setBucketTag} overwrites. */
+    addBucketTag(bucketErn: string, key: string, value: string): Promise<void>;
+    /** Tags a bucket, overwriting any value the key already had. */
+    setBucketTag(bucketErn: string, key: string, value: string): Promise<void>;
+    /** Removes a tag from a bucket. */
+    deleteBucketTag(bucketErn: string, key: string): Promise<void>;
+    /**
+     * One page of a bucket's objects, and how many it holds in total.
+     *
+     * Keys are opaque strings, so a bucket only has "directories" in the sense that keys share a prefix;
+     * the markers for them are left out unless `includeDirectories` asks for them.
+     */
+    listObjects(bucketErn: string, options?: ListObjectsOptions): Promise<Page<EsmObject>>;
+    /**
+     * How many objects a bucket holds. Cheaper than listing them when only the number matters - the
+     * server counts rather than paging every object back to the caller.
+     */
+    getObjectCount(bucketErn: string, prefix?: string): Promise<number>;
+    /** Deletes one object, by its own ERN. */
+    deleteObject(ern: string): Promise<void>;
+    /**
+     * Deletes several named objects from a bucket in one call.
+     *
+     * A key that names no object is not an error, so the result reports both how many keys were asked
+     * for and how many objects went. Deleting everything under a prefix is {@link purgeBucket} rather
+     * than a variant of this - the server refuses keys and a prefix in the same request, since answering
+     * both would delete more than either.
+     *
+     * `background` has the server answer as soon as it has taken the work on rather than when it has
+     * finished, in which case the count is what it took on.
+     */
+    deleteObjects(bucketErn: string, keys: readonly string[], background?: boolean): Promise<DeleteObjectsResult>;
+    /**
+     * Copies an object, leaving the source in place.
+     *
+     * The copy gets its own bytes on disk and its own ERN, so the two are independent from here on. Both
+     * ends are permission-checked, and an existing object at the target is refused with HTTP 409 rather
+     * than silently replaced.
+     */
+    copyObject(sourceBucketErn: string, sourceKey: string, targetBucketErn: string, targetKey: string): Promise<EsmObject>;
+    /**
+     * Moves an object to another bucket or key, removing the source.
+     *
+     * The bytes are not copied - the same file answers to a different key from now on - so this costs
+     * the same whatever the object's size. Refuses an existing target exactly as {@link copyObject} does.
+     */
+    moveObject(sourceBucketErn: string, sourceKey: string, targetBucketErn: string, targetKey: string): Promise<EsmObject>;
+    /**
+     * Renames an object within its bucket - a {@link moveObject} that cannot leave it, which is the
+     * whole difference between the two.
+     */
+    renameObject(bucketErn: string, key: string, newKey: string): Promise<EsmObject>;
+    /**
+     * Re-announces objects already in a bucket, so a listener that missed their creation events hears
+     * about them now.
+     *
+     * Nothing about the objects changes - not a byte, not their modified time. "Touch" here means what
+     * it does to listeners, not what it does to storage: a timestamp is something consumers compare
+     * against, and moving it would make this destructive in exactly the way it is trying not to be.
+     *
+     * `background` is what a bucket of any size wants: the announcement is per object, and holding a
+     * request open for all of them is a request that times out.
+     */
+    touchObject(bucketErn: string, options?: TouchObjectOptions): Promise<TouchObjectResult>;
+    /**
+     * Adds a user-defined attribute to an object. One of that name already there keeps its value -
+     * {@link setObjectAttribute} overwrites.
+     *
+     * The value is a {@link Variant}, or a plain value to be tagged as one - see
+     * {@link import("../dto/com.js").variantOf}.
+     */
+    addObjectAttribute(ern: string, name: string, value: VariantInput): Promise<ObjectAttribute>;
+    /** Sets a user-defined attribute on an object, overwriting any value it already had. */
+    setObjectAttribute(ern: string, name: string, value: VariantInput): Promise<ObjectAttribute>;
+    /** Every user-defined attribute of an object, keyed by name. */
+    listObjectAttributes(ern: string): Promise<Record<string, Variant>>;
+    /** Deletes one user-defined attribute from an object. */
+    deleteObjectAttribute(ern: string, name: string): Promise<void>;
+    /**
+     * Announces a bucket's object events to a queue or a topic from now on.
+     *
+     * What lands there is a {@link BucketEvent}, carried as the body of an ordinary message - see
+     * {@link parseBucketEvent}. The filters are applied by the server as it publishes, so a subscription
+     * only ever delivers what it asked for rather than the target receiving everything and discarding
+     * most of it.
+     *
+     * Not idempotent: a second call registers a second subscription and the target then receives every
+     * matching event twice, so a caller that may run twice checks {@link listSubscriptions} first.
+     *
+     * @param bucketErn bucket resource name
+     * @param targetType {@link QUEUE} or {@link TOPIC}, which is also what decides how a bare target
+     *   name is resolved.
+     * @param targetErn target resource name
+     * @param options call options
+     */
+    subscribe(bucketErn: string, targetType: string, targetErn: string, options?: SubscribeOptions): Promise<SubscribeResult>;
+    /**
+     * Removes a subscription, by the ERN {@link subscribe} answered with - not the bucket's, and not the
+     * target's.
+     */
+    unsubscribe(ern: string): Promise<void>;
+    /** Every subscription currently registered on a bucket. */
+    listSubscriptions(bucketErn: string): Promise<Subscription[]>;
+    /**
+     * Uploads an object in a single request, skipping the multipart sequence entirely.
+     *
+     * A string is stored as its UTF-8 bytes, which is what the object then is; anything that matters
+     * about the encoding is the caller's to decide before calling this.
+     *
+     * Takes two attribute maps, which are not the same one - see {@link AttributeOptions}.
+     */
+    putObject(bucketErn: string, key: string, data: Bytes, options?: AttributeOptions): Promise<StoredObject>;
+    /**
+     * Downloads an object's bytes in a single request.
+     *
+     * The size limit is the server's to enforce rather than this client's: a download's size is not
+     * known until the server is asked, unlike an upload's, so the caller declares how large a response
+     * it is willing to take and an object at or above that comes back as HTTP 413.
+     * {@link downloadFile} uses exactly that to decide whether an object needs the multipart path.
+     */
+    getObject(bucketErn: string, key: string, maxInlineSize?: number): Promise<Buffer>;
+    /**
+     * Uploads a local file in parts, several at a time.
+     *
+     * The file is read a part at a time rather than into memory, and no more than `concurrency` parts
+     * are ever in flight, so the memory this costs is bounded by the two together whatever the file's
+     * size. An empty file is one empty part, so that the object exists.
+     *
+     * Attributes belong on the upload rather than added afterwards: completing an upload is finished off
+     * in the background, and the object row written at the end carries what this call supplied - an
+     * attribute added between here and there is overwritten and silently lost.
+     *
+     * @throws {EuclidServiceError} if a part or one of the calls bracketing them failed for good.
+     * @throws {Error} if `partSize` is less than a byte, which the server rejects too.
+     */
+    uploadFile(bucketErn: string, key: string, file: string, options?: UploadOptions): Promise<StoredObject>;
+    /**
+     * Downloads an object to a local file, fetching its parts several at a time.
+     *
+     * An object that fits in one part skips multipart entirely. Unlike an upload - whose source this
+     * client has already stat'ed - a download's size is not known before asking, so the single-request
+     * path is tried first and HTTP 413 is what says the object was too large for it.
+     *
+     * Missing parent directories are created. Answers with the number of bytes written.
+     *
+     * @throws {Error} if `partSize` is less than a byte, which the server rejects too.
+     */
+    downloadFile(bucketErn: string, key: string, file: string, options?: DownloadOptions): Promise<number>;
+    /**
+     * ESM's own metrics, as the server collects them. Answered unparsed - the shape belongs to the
+     * monitoring module rather than to ESM.
+     */
+    metrics(): Promise<Record<string, unknown>>;
+    /**
+     * The byte-carrying actions, on this client's transfer timeout rather than the session's - a 5 MiB
+     * part on a slow link is not an action that answers from a database.
+     */
+    protected postBytes(action: string, data: Bytes, headers?: Record<string, string>, timeoutMs?: number): Promise<Response>;
+}
+//# sourceMappingURL=esm.d.ts.map

package/dist/modules/esm.d.ts.map

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