@nxgt/s3 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,213 @@
+# @nxgt/s3
+
+S3 on **Bun's own client** — no AWS SDK. A bucket is described once: which
+bucket, how a key is built from the things that identify an object, and what
+this application is willing to put there. Writes that break those rules are
+refused **before anything is sent**, and presigned URLs come from the same
+definition.
+
+```ts
+import { bindBucket, defineBucket } from '@nxgt/s3';
+
+export const avatars = defineBucket({
+	bucket: 'avatars',
+	key: (p: { userId: string }) => `${p.userId}.png`,
+	contentType: ['image/png', 'image/jpeg'],
+	maxSize: 2 * 1024 * 1024,                   // bytes
+});
+
+const store = bindBucket(avatars, {
+	endpoint: process.env.S3_ENDPOINT,
+	accessKeyId: process.env.S3_KEY,
+	secretAccessKey: process.env.S3_SECRET,
+});
+
+await store.put({ userId: 'u1' }, png, { type: 'image/png' });
+const url = store.presignGet({ userId: 'u1' }, { expiresIn: 300 }); // seconds
+```
+
+`store.client` is Bun's `S3Client`, and `store.file(params)` its `S3File`:
+everything this package does not wrap is still there.
+
+> **0.x, on Bun's `S3Client`.** The API is still settling.
+
+## Install
+
+```sh
+bun add @nxgt/s3 typescript
+```
+
+- **Bun 1.4 or later, and Bun only.** `S3Client` is built into Bun, which is
+  why there is no SDK to install — and why this package does not run on Node.
+- `typescript` `^6.0.3`: required peer, the version every `@nxgt` package pins.
+- Tested against SeaweedFS 4.47's S3 gateway. Anything S3-compatible that Bun
+  can sign for will do; a service that is not AWS wants
+  `virtualHostedStyle: false`.
+
+## What it does not do
+
+- **No multipart upload.** A body goes in one `put`. Bun's own
+  `file.writer()` is there for the rest, through `store.file(params)`.
+- **No bucket administration.** Creating, deleting and configuring a bucket is
+  not this package's, and Bun's client has no `createBucket` either.
+- **No copy or move.** `store.client` is where those live when Bun grows them.
+- **It adds no retry and no cache of its own.** A failed request comes back
+  with S3's own error. Bun's client does retry — `retry`, three attempts by
+  default — and that option is passed through like the rest.
+
+## API
+
+### `defineBucket({ bucket, key, contentType, maxSize })`
+
+Describes a bucket; it talks to nothing, so the definition is what a server
+and a worker share. The key is a **function**, so nothing is spelled by hand
+at a call site and a renamed parameter is a compile error.
+
+| Field | |
+| --- | --- |
+| `bucket` | the bucket's name on the service |
+| `key` | `(params) => string`, the object's key |
+| `contentType` | a type, or a list of them, that this bucket accepts. Left out, anything goes |
+| `maxSize` | the biggest body in **bytes**. Left out, anything goes |
+
+### `bindBucket(definition, options?)`
+
+`options` is Bun's own `S3Options` without `bucket`, passed through whole —
+`endpoint`, `accessKeyId`, `secretAccessKey`, `region`, `sessionToken`,
+`virtualHostedStyle`, and also `acl`, `storageClass`, `retry`, `partSize` and
+`queueSize`. It is optional: given none, Bun reads its own `S3_*` / `AWS_*`
+environment variables. Each bound bucket holds an `S3Client` of its own: S3 is
+stateless HTTP, so there is no connection to share and nothing to close.
+
+| `BoundBucket<P>` | |
+| --- | --- |
+| `client` | the `S3Client` this holds |
+| `keyFor(params)` | the key it would use |
+| `file(params)` | Bun's lazy `S3File`: `.stream()`, `.slice()`, `.writer()` |
+| `put(params, body, options?)` | writes it, once the content type and size have accepted it. `options.type` names the body's content type; a `Blob` is asked for its own when none is given |
+| `bytes(params)` | the bytes, or `undefined` when there is no such object |
+| `text(params)` | the body as text, or `undefined` |
+| `exists(params)` | |
+| `stat(params)` | Bun's `S3Stats` — `size`, `lastModified`, `etag`, `type` — or `undefined`. Note `etag`, lower case: that is Bun's field. A listing's `StoredObject` says `eTag` |
+| `delete(params)` | |
+| `list({ prefix, limit, cursor })` | one `ObjectPage` |
+| `presignGet(params, { expiresIn, acl })` | a signed URL that reads it |
+| `presignPut(params, { expiresIn, acl })` | a signed URL that writes it. It takes no `type` — see the Traps |
+
+### Listing
+
+```ts
+let cursor: string | null = null;
+do {
+	const page = await store.list({ prefix: 'u1/', limit: 100, cursor });
+	for (const object of page.items) console.log(object.key, object.size);
+	cursor = page.nextCursor;
+} while (cursor !== null);
+```
+
+`ObjectPage` is the same shape as the `CursorPage` of `@nxgt/drizzle` and
+`@nxgt/mongo`, so a caller pages the same way everywhere: `items`, and a
+`nextCursor` that is `null` on the last page. S3's `continuationToken` is what
+it carries.
+
+### Types
+
+| Type | |
+| --- | --- |
+| `BucketDefinition<P>` | what `defineBucket` takes and gives back |
+| `BoundBucket<P>` | what `bindBucket` gives back |
+| `ObjectPage` | `{ items: StoredObject[]; nextCursor: string \| null }` |
+| `StoredObject` | `{ key: string; size: number \| undefined; lastModified: Date \| undefined; eTag: string \| undefined }` — S3 does not promise the last three, so they are optional here |
+| `PresignOptions` | `{ expiresIn?: number; acl?: … }` |
+| `ParamsOf<D>` | what a definition's `key` takes, for a caller writing its own helper |
+| `PutBody` | everything Bun's `write` takes |
+
+`stat` gives back Bun's own `S3Stats`, which this package does not re-export;
+import it from `bun` where you need to name it.
+
+## Errors
+
+`S3Error` is what this package throws, and **every one of them is thrown
+before anything is sent**. It carries a `code` and the object `key` — never
+the body, never a credential.
+
+```ts
+if (error instanceof S3Error && error.code === 'TOO_LARGE') {
+	return c.json({ error: 'That file is too big' }, 413);
+}
+```
+
+| `S3ErrorCode` | |
+| --- | --- |
+| `WRONG_TYPE` | the body's content type is not one this bucket accepts — or the write named none and the bucket names some |
+| `TOO_LARGE` | the body is bigger than `maxSize` |
+| `UNMEASURABLE` | `maxSize` is set and the body's size cannot be known before sending |
+
+`defineBucket` throws a `TypeError` for a definition that could never work: an
+empty `bucket`, a `maxSize` that is not a positive number, an empty list of
+content types. S3's own failures come back as they are, from Bun's client —
+and **Bun names those `S3Error` too**, with S3's codes (`NoSuchKey` and the
+rest). Discriminate with `instanceof S3Error` on this package's class, never
+with `error.name`.
+
+## What does not compile
+
+Each is a `@ts-expect-error` case in `test/types/s3.ts`.
+
+- An object read, written, deleted or signed for with the wrong key
+  parameters, and a `put` given a misspelt option.
+- A `presignPut` given a `type`: a presigned PUT constrains no content type,
+  so it takes none.
+- A definition with no `bucket`, no `key`, a `key` that gives something other
+  than a string, a `maxSize` that is not a number, or a misspelt option.
+- A presigned URL asked for without the params that identify the object, or
+  with an `expiresIn` that is not a number.
+- A listing asked for by page number, or a page read for a `total` — it pages
+  by cursor, and S3 does not count.
+
+## Traps
+
+- **The guards are `put`'s, not the bucket's.** `contentType` and `maxSize`
+  are checked here, in `put`, before the request goes out. They cost nothing
+  and they catch the honest mistake, but nothing else on the object goes
+  through them: `store.file(params).writer()` and `store.client` are Bun's own
+  and write whatever they are given, and **anyone holding a presigned PUT can
+  ignore them entirely**. Set the service's own policy too where it matters.
+- **A presigned PUT constrains the key and the deadline, and nothing else.**
+  Not the size, not the content type — measured on Bun 1.4: `presign`'s `type`
+  only adds `response-content-type`, which is S3's override for what a
+  *download* is labelled, and `X-Amz-SignedHeaders` stays `host`, so the
+  uploader's `Content-Type` is never signed. A URL signed for a `text/csv`
+  bucket stores a zip happily. That is why `presignPut` takes no `type` at
+  all: it would read as a guarantee it cannot make. Check with `stat` after
+  the upload, or enforce it in the bucket's own policy.
+- **A body whose size cannot be known is refused, not streamed.** With
+  `maxSize` set, a `Response`, a `Request` or another `S3File` throws
+  `UNMEASURABLE`: nothing can check a length it has not read — an `S3File`
+  reports its size as `NaN` until the service has been asked. Read it into
+  memory first, or leave `maxSize` out and let the service refuse it.
+- **A content type is compared on its essence.** `text/csv` accepts
+  `text/csv;charset=utf-8` and `TEXT/CSV`, because that is what real bodies
+  carry: `Bun.file('a.csv').type` is `text/csv;charset=utf-8`, and a text
+  `Blob` adds the charset by itself. Parameters and case are ignored; nothing
+  else is.
+- **A string body is measured in bytes, not in characters**, and `maxSize` is
+  inclusive: 1024 passes, 1025 does not.
+- **`expiresIn` is seconds, and Bun's default is a day.** Always pass one.
+- **A key is built, never guessed.** `keyFor` is there so a caller that needs
+  the string gets *the* string; building one by hand somewhere else is how a
+  bucket ends up with two spellings of the same object.
+- **`delete` does not say whether anything was there.** S3 answers the same
+  either way, and this package does not pretend otherwise. Call `exists`
+  first when it matters.
+- **A listing is eventually consistent on some services**, and `limit` is a
+  maximum, not a promise: a page may come back shorter with a `nextCursor`
+  still set. Page until `nextCursor` is `null`, never until a page is short.
+- **`undefined` means "no such object", and nothing else.** `bytes`, `text`
+  and `stat` read in one round trip and turn S3's own `NoSuchKey` into
+  `undefined`; every other failure — a wrong secret, a refused request, a
+  service that is down — comes back as the error it is.
+
+## License
+
+MIT

package/dist/bucket/bind-bucket.d.ts

@@ -0,0 +1,58 @@
+import { S3Client, type S3File, type S3Options, type S3Stats } from 'bun';
+import { type PresignOptions } from './operations/presign';
+import type { BucketDefinition, ObjectPage, PutBody } from './types';
+export type { PresignOptions };
+/** A bucket bound to credentials: the definition, with somewhere to put it. */
+export interface BoundBucket<P> {
+    /** The client this holds, for anything this package does not wrap. */
+    readonly client: S3Client;
+    /** The key this would use, for a caller that needs the string itself. */
+    keyFor(params: P): string;
+    /** Bun's own lazy handle: `.stream()`, `.slice()`, `.writer()` and the rest. */
+    file(params: P): S3File;
+    /** Writes it, once the bucket's content type and size have accepted it. */
+    put(params: P, body: PutBody, options?: {
+        type?: string;
+    }): Promise<void>;
+    /** The bytes, or `undefined` when there is no such object. */
+    bytes(params: P): Promise<Uint8Array | undefined>;
+    /** The body as text, or `undefined` when there is no such object. */
+    text(params: P): Promise<string | undefined>;
+    exists(params: P): Promise<boolean>;
+    /** What the service knows about it, or `undefined` when it is not there. */
+    stat(params: P): Promise<S3Stats | undefined>;
+    /** Removes it. S3 does not say whether anything was there, and nor does this. */
+    delete(params: P): Promise<void>;
+    /** One page of the bucket, in this repository's cursor shape. */
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<ObjectPage>;
+    /** A URL that reads this object, signed. */
+    presignGet(params: P, options?: PresignOptions): string;
+    /**
+     * A URL that writes this object, signed. It constrains the key and the
+     * deadline, and **nothing else** — not the size, not the content type.
+     */
+    presignPut(params: P, options?: PresignOptions): string;
+}
+/**
+ * Binds a bucket definition to credentials.
+ *
+ * ```ts
+ * const store = bindBucket(avatars, {
+ * 	endpoint: process.env.S3_ENDPOINT,
+ * 	accessKeyId: process.env.S3_KEY,
+ * 	secretAccessKey: process.env.S3_SECRET,
+ * });
+ * await store.put({ userId: 'u1' }, png, { type: 'image/png' });
+ * ```
+ *
+ * Given no options, Bun reads its own `S3_*` / `AWS_*` environment variables.
+ *
+ * Each bound bucket holds an `S3Client` of its own. S3 is stateless HTTP —
+ * there is no connection to share, and nothing to close.
+ */
+export declare function bindBucket<P>(definition: BucketDefinition<P>, options?: Omit<S3Options, 'bucket'>): BoundBucket<P>;
+//# sourceMappingURL=bind-bucket.d.ts.map

package/dist/bucket/bind-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-bucket.d.ts","sourceRoot":"","sources":["../../src/bucket/bind-bucket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,CAAC;AAG1E,OAAO,EACN,KAAK,cAAc,EAGnB,MAAM,sBAAsB,CAAC;AAQ9B,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAErE,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,WAAW,WAAW,CAAC,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,yEAAyE;IACzE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC;IAC1B,gFAAgF;IAChF,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC;IACxB,2EAA2E;IAC3E,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,8DAA8D;IAC9D,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IAClD,qEAAqE;IACrE,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpC,4EAA4E;IAC5E,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC;IAC9C,iFAAiF;IACjF,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,iEAAiE;IACjE,IAAI,CAAC,OAAO,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACvB,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACxB,4CAA4C;IAC5C,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACxD;;;OAGG;IACH,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC3B,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,OAAO,GAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAM,GACrC,WAAW,CAAC,CAAC,CAAC,CAoBhB"}

package/dist/bucket/context.d.ts

@@ -0,0 +1,24 @@
+import type { S3Client } from 'bun';
+import type { BucketDefinition } from './types';
+/**
+ * What every operation of a bound bucket works from, resolved once: the
+ * client, the definition, and the accepted content types as a list.
+ *
+ * It holds **data only**. The operations are plain functions that take it as
+ * their first argument, in `guards.ts` and `operations/` — a context of
+ * closures would only be the factory this package split up, one size down.
+ */
+export interface BucketContext<P> {
+    readonly client: S3Client;
+    readonly definition: BucketDefinition<P>;
+    /**
+     * The types the definition accepts, always as a list, **as written** —
+     * an error message quotes these, and the comparison normalises them.
+     * `undefined` when the bucket accepts anything.
+     */
+    readonly accepted: readonly string[] | undefined;
+}
+export declare function bucketContext<P>(client: S3Client, definition: BucketDefinition<P>): BucketContext<P>;
+/** The key this definition builds for these parameters. */
+export declare function keyOf<P>(context: BucketContext<P>, params: P): string;
+//# sourceMappingURL=context.d.ts.map

package/dist/bucket/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/bucket/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACzC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACjD;AAUD,wBAAgB,aAAa,CAAC,CAAC,EAC9B,MAAM,EAAE,QAAQ,EAChB,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC7B,aAAa,CAAC,CAAC,CAAC,CAMlB;AAED,2DAA2D;AAC3D,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAErE"}

package/dist/bucket/define-bucket.d.ts

@@ -0,0 +1,16 @@
+import type { BucketDefinition } from './types';
+/**
+ * Describes a bucket. It talks to nothing: `bindBucket` is what needs
+ * credentials.
+ *
+ * ```ts
+ * export const avatars = defineBucket({
+ * 	bucket: 'avatars',
+ * 	key: (p: { userId: string }) => `${p.userId}.png`,
+ * 	contentType: ['image/png', 'image/jpeg'],
+ * 	maxSize: 2 * 1024 * 1024,
+ * });
+ * ```
+ */
+export declare function defineBucket<P>(definition: BucketDefinition<P>): BucketDefinition<P>;
+//# sourceMappingURL=define-bucket.d.ts.map

package/dist/bucket/define-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-bucket.d.ts","sourceRoot":"","sources":["../../src/bucket/define-bucket.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC7B,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC7B,gBAAgB,CAAC,CAAC,CAAC,CAsBrB"}

package/dist/bucket/guards.d.ts

@@ -0,0 +1,25 @@
+import type { BucketContext } from './context';
+import type { PutBody } from './types';
+/**
+ * A content type without its parameters, lower-cased: `text/plain` from
+ * `text/plain;charset=utf-8`.
+ *
+ * Both sides of the comparison go through this, because the type a body
+ * carries is rarely the bare one a definition names — `Bun.file('a.json')`
+ * reports `application/json;charset=utf-8` (measured on bun 1.4.2), and an
+ * explicit `IMAGE/PNG` is the same type as `image/png`.
+ */
+export declare function essenceOf(type: string): string;
+/**
+ * The type a write would carry: the one the caller named, or the one the
+ * body knows about itself. One function, so the type `check` approves and
+ * the type `put` sends can never be two different answers.
+ */
+export declare function effectiveType(body: PutBody, named: string | undefined): string | undefined;
+/** The body's size, or `undefined` when it cannot be known before sending. */
+export declare function sizeOf(body: PutBody): number | undefined;
+/** Refuses a type the bucket does not accept. Shared by `put` and `presign`. */
+export declare function checkType<P>(context: BucketContext<P>, key: string, type: string | undefined): void;
+/** Refuses a body the bucket does not accept, before anything is sent. */
+export declare function checkSize<P>(context: BucketContext<P>, key: string, body: PutBody): void;
+//# sourceMappingURL=guards.d.ts.map

package/dist/bucket/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/bucket/guards.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,GAAG,SAAS,CAGpB;AAED,8EAA8E;AAC9E,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAaxD;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,CAAC,EAC1B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GAAG,SAAS,GACtB,IAAI,CAmBN;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,CAAC,EAC1B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,GACX,IAAI,CAoBN"}

package/dist/bucket/operations/list.d.ts

@@ -0,0 +1,9 @@
+import type { BucketContext } from '../context';
+import type { ObjectPage } from '../types';
+/** One page of the bucket, in this repository's cursor shape. */
+export declare function listObjects<P>(context: BucketContext<P>, options?: {
+    prefix?: string;
+    limit?: number;
+    cursor?: string | null;
+}): Promise<ObjectPage>;
+//# sourceMappingURL=list.d.ts.map

package/dist/bucket/operations/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/bucket/operations/list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,UAAU,CAAC;AAEzD,iEAAiE;AACjE,wBAAsB,WAAW,CAAC,CAAC,EAClC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GACvE,OAAO,CAAC,UAAU,CAAC,CAsBrB"}

package/dist/bucket/operations/presign.d.ts

@@ -0,0 +1,23 @@
+import type { S3Options } from 'bun';
+import { type BucketContext } from '../context';
+/** How a presigned URL is asked for. `expiresIn` is **seconds**, as S3's is. */
+export interface PresignOptions {
+    /** Seconds until it expires. Bun's default is a day; give one. */
+    expiresIn?: number;
+    /** `public-read` and the rest, when the service honours it. */
+    acl?: S3Options['acl'];
+}
+export declare function presignGetUrl<P>(context: BucketContext<P>, params: P, options?: PresignOptions): string;
+/**
+ * A URL that writes this object, signed.
+ *
+ * It carries **no content type**, and takes none. Measured on bun 1.4.2:
+ * `presign`'s `type` only adds `response-content-type`, S3's override for
+ * what a *download* is labelled; `X-Amz-SignedHeaders` stays `host`, so the
+ * `Content-Type` the uploader sends is not signed and not constrained. A PUT
+ * signed for a `text/csv` bucket stores an `application/zip` body happily —
+ * measured against this package's own test service, status 200. Naming a type
+ * here would only look like a guarantee.
+ */
+export declare function presignPutUrl<P>(context: BucketContext<P>, params: P, options?: PresignOptions): string;
+//# sourceMappingURL=presign.d.ts.map

package/dist/bucket/operations/presign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presign.d.ts","sourceRoot":"","sources":["../../../src/bucket/operations/presign.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,EAAE,KAAK,aAAa,EAAS,MAAM,YAAY,CAAC;AAEvD,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC9B,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,GAAG,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;CACvB;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC9B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,cAAc,GACtB,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC9B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,cAAc,GACtB,MAAM,CAKR"}

package/dist/bucket/operations/reads.d.ts

@@ -0,0 +1,7 @@
+import type { S3Stats } from 'bun';
+import { type BucketContext } from '../context';
+export declare function readBytes<P>(context: BucketContext<P>, params: P): Promise<Uint8Array | undefined>;
+export declare function readText<P>(context: BucketContext<P>, params: P): Promise<string | undefined>;
+export declare function statObject<P>(context: BucketContext<P>, params: P): Promise<S3Stats | undefined>;
+export declare function objectExists<P>(context: BucketContext<P>, params: P): Promise<boolean>;
+//# sourceMappingURL=reads.d.ts.map

package/dist/bucket/operations/reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reads.d.ts","sourceRoot":"","sources":["../../../src/bucket/operations/reads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,OAAO,EAAE,MAAM,KAAK,CAAC;AAC3C,OAAO,EAAE,KAAK,aAAa,EAAS,MAAM,YAAY,CAAC;AAwBvD,wBAAgB,SAAS,CAAC,CAAC,EAC1B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEjC;AAED,wBAAgB,QAAQ,CAAC,CAAC,EACzB,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE7B;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC3B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAE9B;AAED,wBAAgB,YAAY,CAAC,CAAC,EAC7B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,OAAO,CAAC,CAElB"}

package/dist/bucket/operations/writes.d.ts

@@ -0,0 +1,12 @@
+import { type BucketContext } from '../context';
+import type { PutBody } from '../types';
+/**
+ * Writes it, once the bucket's content type and size have accepted it. Both
+ * guards run before `write` is called, so a refused body is never sent.
+ */
+export declare function putObject<P>(context: BucketContext<P>, params: P, body: PutBody, options?: {
+    type?: string;
+}): Promise<void>;
+/** Removes it. S3 does not say whether anything was there, and nor does this. */
+export declare function deleteObject<P>(context: BucketContext<P>, params: P): Promise<void>;
+//# sourceMappingURL=writes.d.ts.map

package/dist/bucket/operations/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../../src/bucket/operations/writes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAS,MAAM,YAAY,CAAC;AAEvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC;;;GAGG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAChC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,OAAO,EACb,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,CAAC,EAC7B,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,MAAM,EAAE,CAAC,GACP,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/bucket/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * One bucket: which one it is, how an object's key is built from the things
+ * that identify it, and what this application is willing to put in it.
+ *
+ * The key is a **function**, not a template, so nothing is spelled by hand at
+ * a call site and a renamed parameter is a compile error.
+ */
+export interface BucketDefinition<P> {
+    /** The bucket's name on the service. */
+    readonly bucket: string;
+    /** The object's key, from whatever identifies it. */
+    readonly key: (params: P) => string;
+    /**
+     * The content types this bucket accepts. A write of anything else is
+     * refused **before it is sent**. Left out, anything goes.
+     */
+    readonly contentType?: string | readonly string[];
+    /**
+     * The biggest body this bucket accepts, in bytes, refused before it is
+     * sent. Left out, anything goes — see the Traps about bodies whose size
+     * cannot be known in advance.
+     */
+    readonly maxSize?: number;
+}
+/** What a listing says about one object. */
+export interface StoredObject {
+    key: string;
+    /** Bytes, or `undefined` when the service did not say. */
+    size: number | undefined;
+    lastModified: Date | undefined;
+    eTag: string | undefined;
+}
+/**
+ * One page of a listing. The same shape as the `CursorPage` of
+ * `@nxgt/drizzle` and `@nxgt/mongo`, so a caller pages the same way here —
+ * S3's `continuationToken` is what `nextCursor` carries.
+ */
+export interface ObjectPage {
+    items: StoredObject[];
+    /** Pass it as `cursor` for the next page; `null` on the last one. */
+    nextCursor: string | null;
+}
+/** What a definition's `key` takes, so a caller can write its own helper. */
+export type ParamsOf<D> = D extends BucketDefinition<infer P> ? P : never;
+import type { S3Client } from 'bun';
+/**
+ * Everything Bun's own `write` takes — a string, bytes, a `Blob`, a stream, a
+ * `Response`. A bucket with a `maxSize` refuses the ones whose size cannot be
+ * known before sending; one without accepts them all.
+ */
+export type PutBody = Parameters<S3Client['write']>[1];
+//# sourceMappingURL=types.d.ts.map

package/dist/bucket/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/bucket/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAClC,wCAAwC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,MAAM,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAClD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,qEAAqE;IACrE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,gBAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEpC;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/errors/s3-error.d.ts

@@ -0,0 +1,20 @@
+/** What went wrong. Each one is documented in the README's Traps. */
+export type S3ErrorCode = 
+/** The body's content type is not one this bucket accepts. */
+'WRONG_TYPE'
+/** The body is bigger than this bucket's `maxSize`. */
+ | 'TOO_LARGE'
+/** The body's size cannot be known before sending, and `maxSize` is set. */
+ | 'UNMEASURABLE';
+/**
+ * This package's only error, and every one of them is thrown **before**
+ * anything is sent. S3's own failures come back as they are, from Bun's
+ * client.
+ */
+export declare class S3Error extends Error {
+    readonly code: S3ErrorCode;
+    /** The object key it was about — the bucket and the key, never the body. */
+    readonly key: string;
+    constructor(code: S3ErrorCode, key: string, message: string);
+}
+//# sourceMappingURL=s3-error.d.ts.map

package/dist/errors/s3-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3-error.d.ts","sourceRoot":"","sources":["../../src/errors/s3-error.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,MAAM,MAAM,WAAW;AACtB,8DAA8D;AAC5D,YAAY;AACd,uDAAuD;GACrD,WAAW;AACb,4EAA4E;GAC1E,cAAc,CAAC;AAElB;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,4EAA4E;IAC5E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAM3D"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { BoundBucket, PresignOptions } from './bucket/bind-bucket';
+export { bindBucket } from './bucket/bind-bucket';
+export { defineBucket } from './bucket/define-bucket';
+export type { BucketDefinition, ObjectPage, ParamsOf, PutBody, StoredObject, } from './bucket/types';
+export type { S3ErrorCode } from './errors/s3-error';
+export { S3Error } from './errors/s3-error';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,YAAY,EACX,gBAAgB,EAChB,UAAU,EACV,QAAQ,EACR,OAAO,EACP,YAAY,GACZ,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,185 @@
+// src/bucket/bind-bucket.ts
+import { S3Client } from "bun";
+
+// src/bucket/context.ts
+function acceptedTypes(contentType) {
+  if (contentType === undefined)
+    return;
+  return typeof contentType === "string" ? [contentType] : contentType;
+}
+function bucketContext(client, definition) {
+  return {
+    client,
+    definition,
+    accepted: acceptedTypes(definition.contentType)
+  };
+}
+function keyOf(context, params) {
+  return context.definition.key(params);
+}
+
+// src/bucket/operations/list.ts
+async function listObjects(context, options = {}) {
+  const answer = await context.client.list({
+    prefix: options.prefix,
+    maxKeys: options.limit,
+    continuationToken: options.cursor ?? undefined
+  });
+  const contents = answer.contents ?? [];
+  const items = contents.map((found) => ({
+    key: found.key,
+    size: found.size,
+    lastModified: found.lastModified ? new Date(found.lastModified) : undefined,
+    eTag: found.eTag
+  }));
+  const next = answer.isTruncated ? answer.nextContinuationToken ?? null : null;
+  return { items, nextCursor: next };
+}
+
+// src/bucket/operations/presign.ts
+function presignGetUrl(context, params, options) {
+  return context.client.presign(keyOf(context, params), {
+    ...options,
+    method: "GET"
+  });
+}
+function presignPutUrl(context, params, options) {
+  return context.client.presign(keyOf(context, params), {
+    ...options,
+    method: "PUT"
+  });
+}
+
+// src/bucket/operations/reads.ts
+async function whenPresent(context, params, read) {
+  try {
+    return await read(context.client.file(keyOf(context, params)));
+  } catch (reason) {
+    if (reason.code === "NoSuchKey")
+      return;
+    throw reason;
+  }
+}
+function readBytes(context, params) {
+  return whenPresent(context, params, (file) => file.bytes());
+}
+function readText(context, params) {
+  return whenPresent(context, params, (file) => file.text());
+}
+function statObject(context, params) {
+  return whenPresent(context, params, (file) => file.stat());
+}
+function objectExists(context, params) {
+  return context.client.exists(keyOf(context, params));
+}
+
+// src/errors/s3-error.ts
+class S3Error extends Error {
+  constructor(code, key, message) {
+    super(message);
+    this.name = "S3Error";
+    this.code = code;
+    this.key = key;
+  }
+}
+
+// src/bucket/guards.ts
+function essenceOf(type) {
+  return (type.split(";")[0] ?? "").trim().toLowerCase();
+}
+function effectiveType(body, named) {
+  return named ?? (body instanceof Blob ? body.type || undefined : undefined);
+}
+function sizeOf(body) {
+  if (typeof body === "string")
+    return Buffer.byteLength(body, "utf8");
+  if (body instanceof Blob) {
+    return Number.isFinite(body.size) ? body.size : undefined;
+  }
+  if (body instanceof ArrayBuffer)
+    return body.byteLength;
+  if (ArrayBuffer.isView(body))
+    return body.byteLength;
+  return;
+}
+function checkType(context, key, type) {
+  const { accepted } = context;
+  if (!accepted)
+    return;
+  const list = accepted.join(", ");
+  if (!type) {
+    throw new S3Error("WRONG_TYPE", key, `"${context.definition.bucket}" accepts ${list}, and this write ` + "names no content type. Pass `type`");
+  }
+  if (!accepted.some((one) => essenceOf(one) === essenceOf(type))) {
+    throw new S3Error("WRONG_TYPE", key, `"${context.definition.bucket}" accepts ${list}, not ${type}`);
+  }
+}
+function checkSize(context, key, body) {
+  const { maxSize, bucket } = context.definition;
+  if (maxSize === undefined)
+    return;
+  const size = sizeOf(body);
+  if (size === undefined) {
+    throw new S3Error("UNMEASURABLE", key, `"${bucket}" has a maxSize, and this body's size cannot be known ` + "before sending it. Read it into memory first, or drop `maxSize` " + "and let the service refuse it");
+  }
+  if (size > maxSize) {
+    throw new S3Error("TOO_LARGE", key, `"${bucket}" accepts ${maxSize} bytes at most, and this body is ${size}`);
+  }
+}
+
+// src/bucket/operations/writes.ts
+async function putObject(context, params, body, options) {
+  const key = keyOf(context, params);
+  const type = effectiveType(body, options?.type);
+  checkType(context, key, type);
+  checkSize(context, key, body);
+  await context.client.write(key, body, type ? { type } : undefined);
+}
+function deleteObject(context, params) {
+  return context.client.delete(keyOf(context, params));
+}
+
+// src/bucket/bind-bucket.ts
+function bindBucket(definition, options = {}) {
+  const client = new S3Client({ ...options, bucket: definition.bucket });
+  const context = bucketContext(client, definition);
+  return {
+    client,
+    keyFor: (params) => keyOf(context, params),
+    file: (params) => client.file(keyOf(context, params)),
+    put: (params, body, putOptions) => putObject(context, params, body, putOptions),
+    bytes: (params) => readBytes(context, params),
+    text: (params) => readText(context, params),
+    exists: (params) => objectExists(context, params),
+    stat: (params) => statObject(context, params),
+    delete: (params) => deleteObject(context, params),
+    list: (listOptions) => listObjects(context, listOptions),
+    presignGet: (params, presignOptions) => presignGetUrl(context, params, presignOptions),
+    presignPut: (params, presignOptions) => presignPutUrl(context, params, presignOptions)
+  };
+}
+// src/bucket/define-bucket.ts
+function defineBucket(definition) {
+  if (definition.bucket.length === 0) {
+    throw new TypeError("defineBucket: a bucket definition needs a bucket");
+  }
+  if (definition.maxSize !== undefined) {
+    const { maxSize } = definition;
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+      throw new TypeError(`defineBucket: "${definition.bucket}" has a maxSize of ${maxSize}; ` + "it is a number of bytes, and must be above zero");
+    }
+  }
+  const types = definition.contentType;
+  if (Array.isArray(types) && types.length === 0) {
+    throw new TypeError(`defineBucket: "${definition.bucket}" accepts an empty list of ` + "content types, so nothing could ever be written. Leave " + "`contentType` out to accept anything");
+  }
+  return Object.freeze({ ...definition });
+}
+export {
+  S3Error,
+  bindBucket,
+  defineBucket
+};
+
+//# debugId=4049B661AFFFECB264756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,18 @@
+{
+  "version": 3,
+  "sources": ["../src/bucket/bind-bucket.ts", "../src/bucket/context.ts", "../src/bucket/operations/list.ts", "../src/bucket/operations/presign.ts", "../src/bucket/operations/reads.ts", "../src/errors/s3-error.ts", "../src/bucket/guards.ts", "../src/bucket/operations/writes.ts", "../src/bucket/define-bucket.ts"],
+  "sourcesContent": [
+    "import { S3Client, type S3File, type S3Options, type S3Stats } from 'bun';\nimport { bucketContext, keyOf } from './context';\nimport { listObjects } from './operations/list';\nimport {\n\ttype PresignOptions,\n\tpresignGetUrl,\n\tpresignPutUrl,\n} from './operations/presign';\nimport {\n\tobjectExists,\n\treadBytes,\n\treadText,\n\tstatObject,\n} from './operations/reads';\nimport { deleteObject, putObject } from './operations/writes';\nimport type { BucketDefinition, ObjectPage, PutBody } from './types';\n\nexport type { PresignOptions };\n\n/** A bucket bound to credentials: the definition, with somewhere to put it. */\nexport interface BoundBucket<P> {\n\t/** The client this holds, for anything this package does not wrap. */\n\treadonly client: S3Client;\n\t/** The key this would use, for a caller that needs the string itself. */\n\tkeyFor(params: P): string;\n\t/** Bun's own lazy handle: `.stream()`, `.slice()`, `.writer()` and the rest. */\n\tfile(params: P): S3File;\n\t/** Writes it, once the bucket's content type and size have accepted it. */\n\tput(params: P, body: PutBody, options?: { type?: string }): Promise<void>;\n\t/** The bytes, or `undefined` when there is no such object. */\n\tbytes(params: P): Promise<Uint8Array | undefined>;\n\t/** The body as text, or `undefined` when there is no such object. */\n\ttext(params: P): Promise<string | undefined>;\n\texists(params: P): Promise<boolean>;\n\t/** What the service knows about it, or `undefined` when it is not there. */\n\tstat(params: P): Promise<S3Stats | undefined>;\n\t/** Removes it. S3 does not say whether anything was there, and nor does this. */\n\tdelete(params: P): Promise<void>;\n\t/** One page of the bucket, in this repository's cursor shape. */\n\tlist(options?: {\n\t\tprefix?: string;\n\t\tlimit?: number;\n\t\tcursor?: string | null;\n\t}): Promise<ObjectPage>;\n\t/** A URL that reads this object, signed. */\n\tpresignGet(params: P, options?: PresignOptions): string;\n\t/**\n\t * A URL that writes this object, signed. It constrains the key and the\n\t * deadline, and **nothing else** — not the size, not the content type.\n\t */\n\tpresignPut(params: P, options?: PresignOptions): string;\n}\n\n/**\n * Binds a bucket definition to credentials.\n *\n * ```ts\n * const store = bindBucket(avatars, {\n * \tendpoint: process.env.S3_ENDPOINT,\n * \taccessKeyId: process.env.S3_KEY,\n * \tsecretAccessKey: process.env.S3_SECRET,\n * });\n * await store.put({ userId: 'u1' }, png, { type: 'image/png' });\n * ```\n *\n * Given no options, Bun reads its own `S3_*` / `AWS_*` environment variables.\n *\n * Each bound bucket holds an `S3Client` of its own. S3 is stateless HTTP —\n * there is no connection to share, and nothing to close.\n */\nexport function bindBucket<P>(\n\tdefinition: BucketDefinition<P>,\n\toptions: Omit<S3Options, 'bucket'> = {},\n): BoundBucket<P> {\n\tconst client = new S3Client({ ...options, bucket: definition.bucket });\n\tconst context = bucketContext(client, definition);\n\treturn {\n\t\tclient,\n\t\tkeyFor: (params) => keyOf(context, params),\n\t\tfile: (params) => client.file(keyOf(context, params)),\n\t\tput: (params, body, putOptions) =>\n\t\t\tputObject(context, params, body, putOptions),\n\t\tbytes: (params) => readBytes(context, params),\n\t\ttext: (params) => readText(context, params),\n\t\texists: (params) => objectExists(context, params),\n\t\tstat: (params) => statObject(context, params),\n\t\tdelete: (params) => deleteObject(context, params),\n\t\tlist: (listOptions) => listObjects(context, listOptions),\n\t\tpresignGet: (params, presignOptions) =>\n\t\t\tpresignGetUrl(context, params, presignOptions),\n\t\tpresignPut: (params, presignOptions) =>\n\t\t\tpresignPutUrl(context, params, presignOptions),\n\t};\n}\n",
+    "import type { S3Client } from 'bun';\nimport type { BucketDefinition } from './types';\n\n/**\n * What every operation of a bound bucket works from, resolved once: the\n * client, the definition, and the accepted content types as a list.\n *\n * It holds **data only**. The operations are plain functions that take it as\n * their first argument, in `guards.ts` and `operations/` — a context of\n * closures would only be the factory this package split up, one size down.\n */\nexport interface BucketContext<P> {\n\treadonly client: S3Client;\n\treadonly definition: BucketDefinition<P>;\n\t/**\n\t * The types the definition accepts, always as a list, **as written** —\n\t * an error message quotes these, and the comparison normalises them.\n\t * `undefined` when the bucket accepts anything.\n\t */\n\treadonly accepted: readonly string[] | undefined;\n}\n\n/** The types a definition accepts, as a list. */\nfunction acceptedTypes(\n\tcontentType: string | readonly string[] | undefined,\n): readonly string[] | undefined {\n\tif (contentType === undefined) return undefined;\n\treturn typeof contentType === 'string' ? [contentType] : contentType;\n}\n\nexport function bucketContext<P>(\n\tclient: S3Client,\n\tdefinition: BucketDefinition<P>,\n): BucketContext<P> {\n\treturn {\n\t\tclient,\n\t\tdefinition,\n\t\taccepted: acceptedTypes(definition.contentType),\n\t};\n}\n\n/** The key this definition builds for these parameters. */\nexport function keyOf<P>(context: BucketContext<P>, params: P): string {\n\treturn context.definition.key(params);\n}\n",
+    "import type { S3ListObjectsResponse } from 'bun';\nimport type { BucketContext } from '../context';\nimport type { ObjectPage, StoredObject } from '../types';\n\n/** One page of the bucket, in this repository's cursor shape. */\nexport async function listObjects<P>(\n\tcontext: BucketContext<P>,\n\toptions: { prefix?: string; limit?: number; cursor?: string | null } = {},\n): Promise<ObjectPage> {\n\tconst answer = await context.client.list({\n\t\tprefix: options.prefix,\n\t\tmaxKeys: options.limit,\n\t\tcontinuationToken: options.cursor ?? undefined,\n\t});\n\tconst contents: NonNullable<S3ListObjectsResponse['contents']> =\n\t\tanswer.contents ?? [];\n\tconst items: StoredObject[] = contents.map((found) => ({\n\t\tkey: found.key,\n\t\tsize: found.size,\n\t\tlastModified: found.lastModified ? new Date(found.lastModified) : undefined,\n\t\teTag: found.eTag,\n\t}));\n\t// `isTruncated` is what says there is more, and it is the only thing that\n\t// does: a service that sends a token on the last page anyway would page\n\t// for ever if the token alone decided. `null` is this repository's\n\t// \"no next page\".\n\tconst next = answer.isTruncated\n\t\t? (answer.nextContinuationToken ?? null)\n\t\t: null;\n\treturn { items, nextCursor: next };\n}\n",
+    "import type { S3Options } from 'bun';\nimport { type BucketContext, keyOf } from '../context';\n\n/** How a presigned URL is asked for. `expiresIn` is **seconds**, as S3's is. */\nexport interface PresignOptions {\n\t/** Seconds until it expires. Bun's default is a day; give one. */\n\texpiresIn?: number;\n\t/** `public-read` and the rest, when the service honours it. */\n\tacl?: S3Options['acl'];\n}\n\nexport function presignGetUrl<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n\toptions?: PresignOptions,\n): string {\n\treturn context.client.presign(keyOf(context, params), {\n\t\t...options,\n\t\tmethod: 'GET',\n\t});\n}\n\n/**\n * A URL that writes this object, signed.\n *\n * It carries **no content type**, and takes none. Measured on bun 1.4.2:\n * `presign`'s `type` only adds `response-content-type`, S3's override for\n * what a *download* is labelled; `X-Amz-SignedHeaders` stays `host`, so the\n * `Content-Type` the uploader sends is not signed and not constrained. A PUT\n * signed for a `text/csv` bucket stores an `application/zip` body happily —\n * measured against this package's own test service, status 200. Naming a type\n * here would only look like a guarantee.\n */\nexport function presignPutUrl<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n\toptions?: PresignOptions,\n): string {\n\treturn context.client.presign(keyOf(context, params), {\n\t\t...options,\n\t\tmethod: 'PUT',\n\t});\n}\n",
+    "import type { S3File, S3Stats } from 'bun';\nimport { type BucketContext, keyOf } from '../context';\n\n/**\n * `undefined` rather than a throw when the object is simply not there.\n *\n * It reads straight away and catches the service's own `NoSuchKey`, rather\n * than asking `exists` first: one round trip instead of two, and no window in\n * which an object deleted between the two turns a promised `undefined` into a\n * throw. `stat` is itself a HEAD, so asking first bought nothing at all.\n */\nasync function whenPresent<P, T>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n\tread: (file: S3File) => Promise<T>,\n): Promise<T | undefined> {\n\ttry {\n\t\treturn await read(context.client.file(keyOf(context, params)));\n\t} catch (reason) {\n\t\t// Bun names its own S3 failures `S3Error` too, and carries S3's code.\n\t\tif ((reason as { code?: unknown }).code === 'NoSuchKey') return undefined;\n\t\tthrow reason;\n\t}\n}\n\nexport function readBytes<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n): Promise<Uint8Array | undefined> {\n\treturn whenPresent(context, params, (file) => file.bytes());\n}\n\nexport function readText<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n): Promise<string | undefined> {\n\treturn whenPresent(context, params, (file) => file.text());\n}\n\nexport function statObject<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n): Promise<S3Stats | undefined> {\n\treturn whenPresent(context, params, (file) => file.stat());\n}\n\nexport function objectExists<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n): Promise<boolean> {\n\treturn context.client.exists(keyOf(context, params));\n}\n",
+    "/** What went wrong. Each one is documented in the README's Traps. */\nexport type S3ErrorCode =\n\t/** The body's content type is not one this bucket accepts. */\n\t| 'WRONG_TYPE'\n\t/** The body is bigger than this bucket's `maxSize`. */\n\t| 'TOO_LARGE'\n\t/** The body's size cannot be known before sending, and `maxSize` is set. */\n\t| 'UNMEASURABLE';\n\n/**\n * This package's only error, and every one of them is thrown **before**\n * anything is sent. S3's own failures come back as they are, from Bun's\n * client.\n */\nexport class S3Error extends Error {\n\treadonly code: S3ErrorCode;\n\t/** The object key it was about — the bucket and the key, never the body. */\n\treadonly key: string;\n\n\tconstructor(code: S3ErrorCode, key: string, message: string) {\n\t\tsuper(message);\n\t\tthis.name = 'S3Error';\n\t\tthis.code = code;\n\t\tthis.key = key;\n\t}\n}\n",
+    "import { S3Error } from '../errors/s3-error';\nimport type { BucketContext } from './context';\nimport type { PutBody } from './types';\n\n/**\n * A content type without its parameters, lower-cased: `text/plain` from\n * `text/plain;charset=utf-8`.\n *\n * Both sides of the comparison go through this, because the type a body\n * carries is rarely the bare one a definition names — `Bun.file('a.json')`\n * reports `application/json;charset=utf-8` (measured on bun 1.4.2), and an\n * explicit `IMAGE/PNG` is the same type as `image/png`.\n */\nexport function essenceOf(type: string): string {\n\treturn (type.split(';')[0] ?? '').trim().toLowerCase();\n}\n\n/**\n * The type a write would carry: the one the caller named, or the one the\n * body knows about itself. One function, so the type `check` approves and\n * the type `put` sends can never be two different answers.\n */\nexport function effectiveType(\n\tbody: PutBody,\n\tnamed: string | undefined,\n): string | undefined {\n\t// A Blob carries its own type; anything else has to be told.\n\treturn named ?? (body instanceof Blob ? body.type || undefined : undefined);\n}\n\n/** The body's size, or `undefined` when it cannot be known before sending. */\nexport function sizeOf(body: PutBody): number | undefined {\n\tif (typeof body === 'string') return Buffer.byteLength(body, 'utf8');\n\t// An `S3File` **is** a `Blob` — measured on bun 1.4.2 — and its `size` is\n\t// `NaN`, because nothing has asked the service yet. Returning that would\n\t// pass the guard silently: `NaN > maxSize` is false, whatever `maxSize` is.\n\tif (body instanceof Blob) {\n\t\treturn Number.isFinite(body.size) ? body.size : undefined;\n\t}\n\tif (body instanceof ArrayBuffer) return body.byteLength;\n\tif (ArrayBuffer.isView(body)) return body.byteLength;\n\t// A stream, a `Response`: nothing says how long it is until it has been\n\t// read, which is what `UNMEASURABLE` is about.\n\treturn undefined;\n}\n\n/** Refuses a type the bucket does not accept. Shared by `put` and `presign`. */\nexport function checkType<P>(\n\tcontext: BucketContext<P>,\n\tkey: string,\n\ttype: string | undefined,\n): void {\n\tconst { accepted } = context;\n\tif (!accepted) return;\n\tconst list = accepted.join(', ');\n\tif (!type) {\n\t\tthrow new S3Error(\n\t\t\t'WRONG_TYPE',\n\t\t\tkey,\n\t\t\t`\"${context.definition.bucket}\" accepts ${list}, and this write ` +\n\t\t\t\t'names no content type. Pass `type`',\n\t\t);\n\t}\n\tif (!accepted.some((one) => essenceOf(one) === essenceOf(type))) {\n\t\tthrow new S3Error(\n\t\t\t'WRONG_TYPE',\n\t\t\tkey,\n\t\t\t`\"${context.definition.bucket}\" accepts ${list}, not ${type}`,\n\t\t);\n\t}\n}\n\n/** Refuses a body the bucket does not accept, before anything is sent. */\nexport function checkSize<P>(\n\tcontext: BucketContext<P>,\n\tkey: string,\n\tbody: PutBody,\n): void {\n\tconst { maxSize, bucket } = context.definition;\n\tif (maxSize === undefined) return;\n\tconst size = sizeOf(body);\n\tif (size === undefined) {\n\t\tthrow new S3Error(\n\t\t\t'UNMEASURABLE',\n\t\t\tkey,\n\t\t\t`\"${bucket}\" has a maxSize, and this body's size cannot be known ` +\n\t\t\t\t'before sending it. Read it into memory first, or drop `maxSize` ' +\n\t\t\t\t'and let the service refuse it',\n\t\t);\n\t}\n\tif (size > maxSize) {\n\t\tthrow new S3Error(\n\t\t\t'TOO_LARGE',\n\t\t\tkey,\n\t\t\t`\"${bucket}\" accepts ${maxSize} bytes at most, and this body is ${size}`,\n\t\t);\n\t}\n}\n",
+    "import { type BucketContext, keyOf } from '../context';\nimport { checkSize, checkType, effectiveType } from '../guards';\nimport type { PutBody } from '../types';\n\n/**\n * Writes it, once the bucket's content type and size have accepted it. Both\n * guards run before `write` is called, so a refused body is never sent.\n */\nexport async function putObject<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n\tbody: PutBody,\n\toptions?: { type?: string },\n): Promise<void> {\n\tconst key = keyOf(context, params);\n\tconst type = effectiveType(body, options?.type);\n\tcheckType(context, key, type);\n\tcheckSize(context, key, body);\n\t// The very type `checkType` approved, and nothing else.\n\tawait context.client.write(key, body, type ? { type } : undefined);\n}\n\n/** Removes it. S3 does not say whether anything was there, and nor does this. */\nexport function deleteObject<P>(\n\tcontext: BucketContext<P>,\n\tparams: P,\n): Promise<void> {\n\treturn context.client.delete(keyOf(context, params));\n}\n",
+    "import type { BucketDefinition } from './types';\n\n/**\n * Describes a bucket. It talks to nothing: `bindBucket` is what needs\n * credentials.\n *\n * ```ts\n * export const avatars = defineBucket({\n * \tbucket: 'avatars',\n * \tkey: (p: { userId: string }) => `${p.userId}.png`,\n * \tcontentType: ['image/png', 'image/jpeg'],\n * \tmaxSize: 2 * 1024 * 1024,\n * });\n * ```\n */\nexport function defineBucket<P>(\n\tdefinition: BucketDefinition<P>,\n): BucketDefinition<P> {\n\tif (definition.bucket.length === 0) {\n\t\tthrow new TypeError('defineBucket: a bucket definition needs a bucket');\n\t}\n\tif (definition.maxSize !== undefined) {\n\t\tconst { maxSize } = definition;\n\t\tif (!Number.isFinite(maxSize) || maxSize <= 0) {\n\t\t\tthrow new TypeError(\n\t\t\t\t`defineBucket: \"${definition.bucket}\" has a maxSize of ${maxSize}; ` +\n\t\t\t\t\t'it is a number of bytes, and must be above zero',\n\t\t\t);\n\t\t}\n\t}\n\tconst types = definition.contentType;\n\tif (Array.isArray(types) && types.length === 0) {\n\t\tthrow new TypeError(\n\t\t\t`defineBucket: \"${definition.bucket}\" accepts an empty list of ` +\n\t\t\t\t'content types, so nothing could ever be written. Leave ' +\n\t\t\t\t'`contentType` out to accept anything',\n\t\t);\n\t}\n\treturn Object.freeze({ ...definition });\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "4049B661AFFFECB264756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@nxgt/s3",
+	"version": "0.1.0",
+	"description": "S3 on Bun's own client: buckets described once, keys built by a typed function, uploads refused before they are sent, and presigned URLs from the same definition",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"README.md",
+		"package.json",
+		"LICENSE"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"keywords": [
+		"s3",
+		"bun",
+		"typescript",
+		"storage",
+		"presigned-url"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/softistx/nxgt-data.git",
+		"directory": "packages/s3"
+	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bun run ../../build.ts",
+		"test": "bun run ../../scripts/seaweedfs.ts && bun test --timeout 30000 src",
+		"typecheck": "tsc --noEmit"
+	},
+	"nxgt": {
+		"entrypoints": [
+			"src/index.ts"
+		]
+	},
+	"devDependencies": {
+		"@types/bun": "^1.4.0"
+	},
+	"peerDependencies": {
+		"typescript": "^6.0.3"
+	}
+}