@pithy-sh/storage 0.1.2 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/capability.d.ts +45 -0
- package/dist/capability.d.ts.map +1 -0
- package/dist/capability.js +76 -0
- package/dist/config/config.d.ts +27 -0
- package/dist/config/config.d.ts.map +1 -0
- package/dist/config/config.js +49 -0
- package/dist/data/share.d.ts +27 -0
- package/dist/data/share.d.ts.map +1 -0
- package/dist/data/share.js +28 -0
- package/dist/data/storageObject.d.ts +55 -0
- package/dist/data/storageObject.d.ts.map +1 -0
- package/dist/data/storageObject.js +44 -0
- package/dist/data/tables.d.ts +23 -0
- package/dist/data/tables.d.ts.map +1 -0
- package/dist/data/tables.js +26 -0
- package/dist/error/errors.d.ts +60 -0
- package/dist/error/errors.d.ts.map +1 -0
- package/dist/error/errors.js +89 -0
- package/dist/http/guard.d.ts +20 -0
- package/dist/http/guard.d.ts.map +1 -0
- package/dist/http/guard.js +29 -0
- package/dist/http/handlers.d.ts +232 -0
- package/dist/http/handlers.d.ts.map +1 -0
- package/dist/http/handlers.js +507 -0
- package/dist/http/routes.d.ts +70 -0
- package/dist/http/routes.d.ts.map +1 -0
- package/dist/http/routes.js +135 -0
- package/dist/http/schemas.d.ts +74 -0
- package/dist/http/schemas.d.ts.map +1 -0
- package/dist/http/schemas.js +93 -0
- package/dist/http/serve.d.ts +121 -0
- package/dist/http/serve.d.ts.map +1 -0
- package/dist/http/serve.js +209 -0
- package/dist/index.d.ts +23 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +14 -0
- package/dist/migrations/0001_objects.d.ts +24 -0
- package/dist/migrations/0001_objects.d.ts.map +1 -0
- package/dist/migrations/0001_objects.js +41 -0
- package/dist/object/cloudflare.d.ts +23 -0
- package/dist/object/cloudflare.d.ts.map +1 -0
- package/dist/object/cloudflare.js +48 -0
- package/dist/object/key.d.ts +29 -0
- package/dist/object/key.d.ts.map +1 -0
- package/dist/object/key.js +37 -0
- package/dist/object/multipart.d.ts +78 -0
- package/dist/object/multipart.d.ts.map +1 -0
- package/dist/object/multipart.js +131 -0
- package/dist/object/store.d.ts +203 -0
- package/dist/object/store.d.ts.map +1 -0
- package/dist/object/store.js +178 -0
- package/dist/provision/provisionStorage.d.ts +139 -0
- package/dist/provision/provisionStorage.d.ts.map +1 -0
- package/dist/provision/provisionStorage.js +112 -0
- package/dist/provision/resolveStorageConfig.d.ts +45 -0
- package/dist/provision/resolveStorageConfig.d.ts.map +1 -0
- package/dist/provision/resolveStorageConfig.js +33 -0
- package/dist/quota/quota.d.ts +127 -0
- package/dist/quota/quota.d.ts.map +1 -0
- package/dist/quota/quota.js +102 -0
- package/dist/secret/registry.d.ts +72 -0
- package/dist/secret/registry.d.ts.map +1 -0
- package/dist/secret/registry.js +84 -0
- package/dist/seeds/example.d.ts +5 -0
- package/dist/seeds/example.d.ts.map +1 -0
- package/dist/seeds/example.js +111 -0
- package/dist/test-utils/liveStorage.d.ts +52 -0
- package/dist/test-utils/liveStorage.d.ts.map +1 -0
- package/dist/test-utils/liveStorage.js +198 -0
- package/dist/version.generated.d.ts +7 -0
- package/dist/version.generated.d.ts.map +1 -0
- package/dist/version.generated.js +9 -0
- package/dist/workflows/retryPolicy.d.ts +39 -0
- package/dist/workflows/retryPolicy.d.ts.map +1 -0
- package/dist/workflows/retryPolicy.js +43 -0
- package/dist/workflows/specs.d.ts +57 -0
- package/dist/workflows/specs.d.ts.map +1 -0
- package/dist/workflows/specs.js +60 -0
- package/dist/workflows/sweep.d.ts +84 -0
- package/dist/workflows/sweep.d.ts.map +1 -0
- package/dist/workflows/sweep.js +145 -0
- package/dist/workflows/worker.d.ts +51 -0
- package/dist/workflows/worker.d.ts.map +1 -0
- package/dist/workflows/worker.js +52 -0
- package/package.json +22 -11
- package/src/version.generated.ts +1 -1
|
@@ -0,0 +1,232 @@
|
|
|
1
|
+
// SPDX-FileCopyrightText: 2026 Pithy
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
import type { StorageConfig } from "../config/config";
|
|
4
|
+
import { StorageObject } from "../data/storageObject";
|
|
5
|
+
import { type StorageDatabase } from "../data/tables";
|
|
6
|
+
import type { ObjectStore, UploadedPart } from "../object/store";
|
|
7
|
+
import type { CompleteUploadInput, CopyObjectInput, CreateShareInput, CreateUploadInput, ListObjectsQuery, UpdateObjectInput } from "./schemas";
|
|
8
|
+
/**
|
|
9
|
+
* The storage request handlers — pure functions over injected dependencies, so every branch is tested
|
|
10
|
+
* against real D1 and real R2 without standing up a Worker. `routes.ts` is a thin shell that resolves
|
|
11
|
+
* these dependencies from the request env and maps their results onto responses.
|
|
12
|
+
*
|
|
13
|
+
* **Request shape is not validated here.** Each route declares its own schemas with
|
|
14
|
+
* `zValidator(target, Schema, validationHook)` and hands the handler the already-parsed value, so a
|
|
15
|
+
* malformed request is refused before a dependency is resolved or a row is read. What survives in
|
|
16
|
+
* these handlers is everything a request schema cannot express — ownership, quota, upload state —
|
|
17
|
+
* which is the whole of what they were ever really about.
|
|
18
|
+
*
|
|
19
|
+
* **The object key never leaves this module.** Every client-facing shape goes through {@link view},
|
|
20
|
+
* which drops `key` and `uploadId`. That is not tidiness: the key is the only thing a presigned URL
|
|
21
|
+
* addresses, so a key in a response body is a capability leak waiting for the first adopter who logs
|
|
22
|
+
* their API responses.
|
|
23
|
+
*
|
|
24
|
+
* **A file you cannot see reads as missing.** `assertOwner` answers `storage/not_found` for a private
|
|
25
|
+
* object owned by someone else and `storage/forbidden` only when the object is already public —
|
|
26
|
+
* because a 403 on a private object confirms it exists, which is exactly the oracle an enumeration
|
|
27
|
+
* attack wants. Public objects have nothing left to hide, so there the honest answer is the useful one.
|
|
28
|
+
*/
|
|
29
|
+
/** Everything a handler needs, all injectable. */
|
|
30
|
+
export interface HandlerDeps {
|
|
31
|
+
/** The storage database. */
|
|
32
|
+
db: StorageDatabase;
|
|
33
|
+
/** The object plane — presigning, the multipart lifecycle, and binding-backed reads. */
|
|
34
|
+
store: ObjectStore;
|
|
35
|
+
/** The resolved storage config: quota, multipart sizing, default visibility. */
|
|
36
|
+
config: StorageConfig;
|
|
37
|
+
/** The authenticated caller from the core `AuthContext` seam, or null for an unauthenticated read. */
|
|
38
|
+
ownerId: string | null;
|
|
39
|
+
/** Mints an object id. */
|
|
40
|
+
newId: () => string;
|
|
41
|
+
/** Mints a share token. */
|
|
42
|
+
newToken: () => string;
|
|
43
|
+
/** The current time. */
|
|
44
|
+
now: () => Date;
|
|
45
|
+
}
|
|
46
|
+
/** The client-facing shape of a stored file. Deliberately without `key` and `uploadId`. */
|
|
47
|
+
export interface StorageObjectView {
|
|
48
|
+
id: string;
|
|
49
|
+
path: string;
|
|
50
|
+
ownerId: string | null;
|
|
51
|
+
contentType: string;
|
|
52
|
+
size: number | null;
|
|
53
|
+
visibility: "private" | "public";
|
|
54
|
+
checksum: string | null;
|
|
55
|
+
status: "pending" | "stored" | "failed";
|
|
56
|
+
createdAt: Date;
|
|
57
|
+
updatedAt: Date;
|
|
58
|
+
}
|
|
59
|
+
/** One part of a multipart upload, with the URL the client PUTs those bytes to. */
|
|
60
|
+
export interface UploadPartTarget {
|
|
61
|
+
partNumber: number;
|
|
62
|
+
offset: number;
|
|
63
|
+
length: number;
|
|
64
|
+
url: string;
|
|
65
|
+
}
|
|
66
|
+
/** Where to send the bytes: one URL, or one per part. */
|
|
67
|
+
export type UploadTarget = {
|
|
68
|
+
kind: "single";
|
|
69
|
+
url: string;
|
|
70
|
+
} | {
|
|
71
|
+
kind: "multipart";
|
|
72
|
+
uploadId: string;
|
|
73
|
+
partSize: number;
|
|
74
|
+
parts: UploadPartTarget[];
|
|
75
|
+
};
|
|
76
|
+
/** What an upload-init answers with: the record's coordinates and where the bytes go. */
|
|
77
|
+
export interface UploadInitResult {
|
|
78
|
+
object: StorageObjectView;
|
|
79
|
+
upload: UploadTarget;
|
|
80
|
+
}
|
|
81
|
+
/** A minted share link. */
|
|
82
|
+
export interface ShareView {
|
|
83
|
+
token: string;
|
|
84
|
+
objectId: string;
|
|
85
|
+
expiresAt: Date | null;
|
|
86
|
+
createdAt: Date;
|
|
87
|
+
}
|
|
88
|
+
/**
|
|
89
|
+
* Start an upload: reserve the row and its quota, then mint the URL(s) the client PUTs to.
|
|
90
|
+
*
|
|
91
|
+
* **The reservation is the insert, and the insert is conditional.** A `pending` row holds its bytes
|
|
92
|
+
* against the owner's quota, so the row has to exist before an upload can proceed — but a check that
|
|
93
|
+
* ran separately from the write would let a burst of concurrent inits each read a used total none of
|
|
94
|
+
* them had yet contributed to. `insertReservingQuota` evaluates the sum inside the write instead, so
|
|
95
|
+
* the tenth concurrent init sees the other nine (`quota/quota.ts`).
|
|
96
|
+
*
|
|
97
|
+
* The pre-check above it is a courtesy: it refuses an obviously oversized upload before an R2
|
|
98
|
+
* multipart upload exists to clean up. When the conditional insert loses the race anyway, that
|
|
99
|
+
* multipart upload is aborted — a refused init leaves R2 holding nothing.
|
|
100
|
+
*/
|
|
101
|
+
export declare function initUpload(deps: HandlerDeps, input: CreateUploadInput): Promise<UploadInitResult>;
|
|
102
|
+
/**
|
|
103
|
+
* Finalize an upload: assemble the parts (for a multipart), then confirm against R2 that the bytes
|
|
104
|
+
* are really there before the row is allowed to claim they are.
|
|
105
|
+
*
|
|
106
|
+
* The `head` is not a formality. Without it a client could complete an upload it never performed and
|
|
107
|
+
* leave a `stored` row pointing at nothing — a 404 from R2 at read time, long after the request that
|
|
108
|
+
* caused it. The size *and the content type* R2 reports win over the declared ones, so the row records
|
|
109
|
+
* what was stored rather than what was promised.
|
|
110
|
+
*
|
|
111
|
+
* **It is also where the quota is settled.** Part URLs carry no signed `Content-Length` — the final
|
|
112
|
+
* part's differs from every other, so pinning one at mint time would mean knowing the total up front
|
|
113
|
+
* and would still leave the last part unconstrained. The declared size therefore buys a *reservation*,
|
|
114
|
+
* not a limit, and an owner who declares 100 MiB can PUT far more across those URLs. Completion is the
|
|
115
|
+
* first and last point where the real byte count is known and the object can still be thrown away, so
|
|
116
|
+
* anything past the reservation is re-asserted against the quota here.
|
|
117
|
+
*
|
|
118
|
+
* **That re-assertion is the write, for the same reason the reservation was.** A check that ran ahead
|
|
119
|
+
* of the `UPDATE` would let two completions racing on one owner both read a total neither had yet
|
|
120
|
+
* contributed to, both pass, and both store — the init race, reproduced at the other end of the
|
|
121
|
+
* lifecycle. `updateSettlingQuota` evaluates the sum inside the update, so the second completion sees
|
|
122
|
+
* the first (`quota/quota.ts`).
|
|
123
|
+
*/
|
|
124
|
+
export declare function completeUpload(deps: HandlerDeps, id: string, input: CompleteUploadInput): Promise<StorageObjectView>;
|
|
125
|
+
/**
|
|
126
|
+
* Abandon an in-flight upload: tell R2 to discard the stored parts, then mark the row `failed`.
|
|
127
|
+
*
|
|
128
|
+
* The row survives rather than being deleted. `failed` rows are excluded from the quota sum, so they
|
|
129
|
+
* hold nothing, and keeping them means an owner can see that an upload was attempted and abandoned
|
|
130
|
+
* instead of the record silently evaporating.
|
|
131
|
+
*
|
|
132
|
+
* **The bytes are R2's problem after this, not the row's.** A single-PUT abort cannot revoke the
|
|
133
|
+
* presigned URL it handed out — nothing can, which is the whole cost of presigning — so a client may
|
|
134
|
+
* still PUT to it for the rest of that URL's hour, after the delete below has run. The row that
|
|
135
|
+
* survives therefore stops *claiming* its key the moment it goes `failed`: the orphan sweep matches
|
|
136
|
+
* only rows that bill for a key, so anything that lands afterwards is collected as an orphan rather
|
|
137
|
+
* than sheltered forever by a row that counts toward no quota (`workflows/sweep.ts`).
|
|
138
|
+
*/
|
|
139
|
+
export declare function abortUpload(deps: HandlerDeps, id: string): Promise<StorageObjectView>;
|
|
140
|
+
/** Where a resuming client stands: what R2 already holds, and a live URL for everything it does not. */
|
|
141
|
+
export interface UploadPartsResult {
|
|
142
|
+
uploadId: string;
|
|
143
|
+
partSize: number;
|
|
144
|
+
partCount: number;
|
|
145
|
+
uploaded: UploadedPart[];
|
|
146
|
+
missing: UploadPartTarget[];
|
|
147
|
+
}
|
|
148
|
+
/**
|
|
149
|
+
* Resume a multipart upload: the parts R2 already holds, plus a **freshly presigned** URL for each
|
|
150
|
+
* one still missing.
|
|
151
|
+
*
|
|
152
|
+
* This is what makes multipart resumable at all. `initUpload` presigns every part once, and those
|
|
153
|
+
* URLs lapse an hour later — a 40 GiB upload is 640 of them, and a client that stalls or dies has no
|
|
154
|
+
* way back to the ones it never sent. Re-minting them here is the recovery path, and it is a route
|
|
155
|
+
* rather than a longer TTL because a presigned URL cannot be revoked: minting on demand keeps each
|
|
156
|
+
* one's life short and its issue authorized.
|
|
157
|
+
*
|
|
158
|
+
* Only while the row is `pending`. A `stored` row has no upload left to resume, and a `failed` one had
|
|
159
|
+
* its parts discarded — re-presigning against either would hand out URLs addressing nothing.
|
|
160
|
+
*/
|
|
161
|
+
export declare function listUploadParts(deps: HandlerDeps, id: string): Promise<UploadPartsResult>;
|
|
162
|
+
/**
|
|
163
|
+
* One page of the caller's files, ordered by logical path. Scoped to the authenticated owner: there
|
|
164
|
+
* is no way to list another owner's files, and no parameter that could be made to.
|
|
165
|
+
*/
|
|
166
|
+
export declare function listObjects(deps: HandlerDeps, query: ListObjectsQuery): Promise<{
|
|
167
|
+
objects: StorageObjectView[];
|
|
168
|
+
cursor?: string;
|
|
169
|
+
}>;
|
|
170
|
+
/** Load an object for reading, enforcing public-or-owner and that its bytes exist. */
|
|
171
|
+
export declare function readableObject(deps: HandlerDeps, id: string): Promise<StorageObject>;
|
|
172
|
+
/** How long a direct-download URL stays valid. Short: it is bearer-equivalent and cannot be revoked. */
|
|
173
|
+
export declare const PRESIGNED_URL_TTL_SECONDS = 300;
|
|
174
|
+
/**
|
|
175
|
+
* Mint a presigned GET — the no-Worker-in-the-byte-path escape hatch.
|
|
176
|
+
*
|
|
177
|
+
* Authorization happens **here**, once, and then the URL is on its own: it cannot be revoked, and
|
|
178
|
+
* anyone holding it can read the bytes until it lapses. Five minutes is short enough that a URL
|
|
179
|
+
* pasted into a chat is dead before it is read, and long enough to start a large download.
|
|
180
|
+
*/
|
|
181
|
+
export declare function presignObject(deps: HandlerDeps, id: string): Promise<{
|
|
182
|
+
url: string;
|
|
183
|
+
expiresInSeconds: number;
|
|
184
|
+
}>;
|
|
185
|
+
/** Rename a file, change who may read it, or both. The key never moves — only the row changes. */
|
|
186
|
+
export declare function updateObject(deps: HandlerDeps, id: string, input: UpdateObjectInput): Promise<StorageObjectView>;
|
|
187
|
+
/**
|
|
188
|
+
* Copy a file server-side. The bytes are copied by R2 and never enter the Worker; the copy is a new
|
|
189
|
+
* object with its own id, its own key, and its own share links — it is not an alias.
|
|
190
|
+
*
|
|
191
|
+
* Owner-scoped, like every other mutating route: you may copy your own files. Copying a *public* file
|
|
192
|
+
* you do not own is a plausible feature and deliberately not this one — it would let any reader
|
|
193
|
+
* duplicate bytes into their own quota on the owner's storage bill, which is a decision an adopter
|
|
194
|
+
* should make explicitly rather than inherit.
|
|
195
|
+
*/
|
|
196
|
+
export declare function copyObject(deps: HandlerDeps, id: string, input: CopyObjectInput): Promise<StorageObjectView>;
|
|
197
|
+
/**
|
|
198
|
+
* Delete a file: the object first, then the row. Every share link pointing at it goes with the row,
|
|
199
|
+
* through the foreign key's `ON DELETE CASCADE` — a share that outlived its object would be a live
|
|
200
|
+
* token for bytes that no longer exist.
|
|
201
|
+
*
|
|
202
|
+
* The object delete is best-effort. An R2 hiccup must not leave a row nobody can remove; the orphan
|
|
203
|
+
* sweep collects an object whose row went first.
|
|
204
|
+
*/
|
|
205
|
+
export declare function deleteObject(deps: HandlerDeps, id: string): Promise<{
|
|
206
|
+
id: string;
|
|
207
|
+
deleted: true;
|
|
208
|
+
}>;
|
|
209
|
+
/** Mint a revocable share link for one file. */
|
|
210
|
+
export declare function createShare(deps: HandlerDeps, id: string, input: CreateShareInput): Promise<ShareView>;
|
|
211
|
+
/**
|
|
212
|
+
* Withdraw a share link. A write, effective on the very next request — which is the whole reason a
|
|
213
|
+
* share is a row and not a presigned URL.
|
|
214
|
+
*
|
|
215
|
+
* Revoking twice is a no-op. The first revocation time is kept, because when a link stopped working
|
|
216
|
+
* is the fact anyone actually needs.
|
|
217
|
+
*/
|
|
218
|
+
export declare function revokeShare(deps: HandlerDeps, token: string): Promise<{
|
|
219
|
+
token: string;
|
|
220
|
+
revokedAt: Date;
|
|
221
|
+
}>;
|
|
222
|
+
/**
|
|
223
|
+
* Resolve a share token to the object it grants read access to.
|
|
224
|
+
*
|
|
225
|
+
* Revoked and expired are **separate answers**, deliberately. Both are 410, but `storage/share_revoked`
|
|
226
|
+
* says the owner took the link back and `storage/share_expired` says it simply aged out — one is worth
|
|
227
|
+
* asking about, the other is worth re-requesting. Collapsing them into "gone" throws away the only
|
|
228
|
+
* information the holder can act on. Revocation is checked first: an explicit withdrawal is the more
|
|
229
|
+
* specific fact about a link that is both.
|
|
230
|
+
*/
|
|
231
|
+
export declare function resolveShare(deps: HandlerDeps, token: string): Promise<StorageObject>;
|
|
232
|
+
//# sourceMappingURL=handlers.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/http/handlers.ts"],"names":[],"mappings":"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"}
|