@antelopejs/dms-media 0.4.1 → 0.5.0
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/README.md +4 -3
- package/dist/bindings.d.ts +4 -1
- package/dist/bindings.js +21 -0
- package/dist/bindings.js.map +1 -1
- package/dist/db/models/index.d.ts +1 -0
- package/dist/db/models/index.js +1 -0
- package/dist/db/models/index.js.map +1 -1
- package/dist/db/models/mediaAssets.model.d.ts +1 -0
- package/dist/db/models/mediaAssets.model.js +19 -0
- package/dist/db/models/mediaAssets.model.js.map +1 -1
- package/dist/db/models/mediaDeclarations.model.d.ts +24 -0
- package/dist/db/models/mediaDeclarations.model.js +13 -0
- package/dist/db/models/mediaDeclarations.model.js.map +1 -0
- package/dist/db/models/mediaFolders.model.d.ts +3 -0
- package/dist/db/models/mediaFolders.model.js +29 -0
- package/dist/db/models/mediaFolders.model.js.map +1 -1
- package/dist/db/tables/index.d.ts +1 -0
- package/dist/db/tables/index.js +1 -0
- package/dist/db/tables/index.js.map +1 -1
- package/dist/db/tables/mediaDeclarations.table.d.ts +15 -0
- package/dist/db/tables/mediaDeclarations.table.js +65 -0
- package/dist/db/tables/mediaDeclarations.table.js.map +1 -0
- package/dist/declared/assets.d.ts +4 -0
- package/dist/declared/assets.js +269 -0
- package/dist/declared/assets.js.map +1 -0
- package/dist/declared/folders.d.ts +10 -0
- package/dist/declared/folders.js +154 -0
- package/dist/declared/folders.js.map +1 -0
- package/dist/declared/index.d.ts +5 -0
- package/dist/declared/index.js +22 -0
- package/dist/declared/index.js.map +1 -0
- package/dist/declared/readiness.d.ts +2 -0
- package/dist/declared/readiness.js +52 -0
- package/dist/declared/readiness.js.map +1 -0
- package/dist/declared/records.d.ts +46 -0
- package/dist/declared/records.js +94 -0
- package/dist/declared/records.js.map +1 -0
- package/dist/declared/retire.d.ts +3 -0
- package/dist/declared/retire.js +118 -0
- package/dist/declared/retire.js.map +1 -0
- package/dist/implementations/interface-dms-media/index.d.ts +5 -0
- package/dist/implementations/interface-dms-media/index.js +5 -0
- package/dist/implementations/interface-dms-media/index.js.map +1 -1
- package/dist/library/events.d.ts +2 -1
- package/dist/library/events.js.map +1 -1
- package/dist/routes/media/assets.js +19 -4
- package/dist/routes/media/assets.js.map +1 -1
- package/dist/routes/media/context.d.ts +1 -1
- package/dist/routes/media/context.js.map +1 -1
- package/dist/routes/media/dto.d.ts +1 -0
- package/dist/routes/media/dto.js +3 -1
- package/dist/routes/media/dto.js.map +1 -1
- package/dist/routes/media/folders.d.ts +6 -0
- package/dist/routes/media/folders.js +25 -13
- package/dist/routes/media/folders.js.map +1 -1
- package/dist/routes/media/upload.d.ts +1 -1
- package/dist/routes/media/upload.js +26 -58
- package/dist/routes/media/upload.js.map +1 -1
- package/dist/test/integration/media-declared-content.test.d.ts +1 -0
- package/dist/test/integration/media-declared-content.test.js +705 -0
- package/dist/test/integration/media-declared-content.test.js.map +1 -0
- package/dist/test/integration/media-declared-retire.test.d.ts +1 -0
- package/dist/test/integration/media-declared-retire.test.js +186 -0
- package/dist/test/integration/media-declared-retire.test.js.map +1 -0
- package/dist/test/integration/media-delivery-editing.test.js +26 -0
- package/dist/test/integration/media-delivery-editing.test.js.map +1 -1
- package/dist/test/integration/media-linked-subfolders.test.d.ts +1 -0
- package/dist/test/integration/media-linked-subfolders.test.js +192 -0
- package/dist/test/integration/media-linked-subfolders.test.js.map +1 -0
- package/dist/test/unit/declared.test.d.ts +1 -0
- package/dist/test/unit/declared.test.js +118 -0
- package/dist/test/unit/declared.test.js.map +1 -0
- package/dist/upload-checks.d.ts +18 -0
- package/dist/upload-checks.js +75 -0
- package/dist/upload-checks.js.map +1 -0
- package/dist/validation/declared.schema.d.ts +187 -0
- package/dist/validation/declared.schema.js +78 -0
- package/dist/validation/declared.schema.js.map +1 -0
- package/dist/validation/media.schema.d.ts +3 -0
- package/dist/validation/media.schema.js +12 -12
- package/dist/validation/media.schema.js.map +1 -1
- package/frontend-vue/app/components/dialogs/DestinationDialog.vue +1 -1
- package/frontend-vue/app/components/dialogs/MoveDialog.vue +2 -2
- package/frontend-vue/app/components/explorer/ExplorerContent.vue +1 -1
- package/frontend-vue/app/components/explorer/ExplorerToolbar.vue +1 -1
- package/frontend-vue/app/components/shared/AssetThumb.vue +3 -1
- package/frontend-vue/app/composables/library/explorerMenus.ts +1 -1
- package/frontend-vue/app/composables/library/useExplorerCommands.ts +1 -1
- package/frontend-vue/app/composables/library/useExplorerDrop.ts +1 -1
- package/frontend-vue/app/types/media.ts +3 -1
- package/frontend-vue/tests/serverRender.test.ts +2 -1
- package/package.json +2 -2
- package/skills/dms-media/SKILL.md +50 -4
- package/src/bindings.ts +28 -0
- package/src/db/models/index.ts +1 -0
- package/src/db/models/mediaAssets.model.ts +25 -0
- package/src/db/models/mediaDeclarations.model.ts +19 -0
- package/src/db/models/mediaFolders.model.ts +44 -0
- package/src/db/tables/index.ts +1 -0
- package/src/db/tables/mediaDeclarations.table.ts +59 -0
- package/src/declared/assets.ts +446 -0
- package/src/declared/folders.ts +273 -0
- package/src/declared/index.ts +5 -0
- package/src/declared/readiness.ts +64 -0
- package/src/declared/records.ts +185 -0
- package/src/declared/retire.ts +206 -0
- package/src/implementations/interface-dms-media/index.ts +10 -0
- package/src/library/events.ts +4 -1
- package/src/routes/media/assets.ts +34 -5
- package/src/routes/media/context.ts +1 -1
- package/src/routes/media/dto.ts +6 -2
- package/src/routes/media/folders.ts +47 -21
- package/src/routes/media/upload.ts +50 -121
- package/src/test/integration/media-declared-content.test.ts +844 -0
- package/src/test/integration/media-declared-retire.test.ts +257 -0
- package/src/test/integration/media-delivery-editing.test.ts +45 -0
- package/src/test/integration/media-linked-subfolders.test.ts +256 -0
- package/src/test/unit/declared.test.ts +158 -0
- package/src/upload-checks.ts +126 -0
- package/src/validation/declared.schema.ts +104 -0
- package/src/validation/media.schema.ts +7 -6
- package/frontend-vue/pnpm-workspace.yaml +0 -2
|
@@ -0,0 +1,446 @@
|
|
|
1
|
+
import { randomUUID } from "node:crypto";
|
|
2
|
+
import { readFile } from "node:fs/promises";
|
|
3
|
+
import { DeleteFile } from "@antelopejs/interface-file-storage";
|
|
4
|
+
import type {
|
|
5
|
+
MediaAssetDeclaration,
|
|
6
|
+
MediaDeclarationResult,
|
|
7
|
+
} from "@antelopejs/interface-dms-media";
|
|
8
|
+
import { cleanupAssetFiles, updateAssetMedia } from "../asset-lifecycle";
|
|
9
|
+
import { feedingBinding } from "../bindings";
|
|
10
|
+
import { getMediaConfig } from "../config";
|
|
11
|
+
import type { MediaAsset, MediaDeclaration, MediaFolder } from "../db";
|
|
12
|
+
import { uploadStorageBytes } from "../derivatives";
|
|
13
|
+
import { recordMediaEvent } from "../library/events";
|
|
14
|
+
import {
|
|
15
|
+
assertReadableImage,
|
|
16
|
+
assertUploadTypeAllowed,
|
|
17
|
+
assertWithinQuota,
|
|
18
|
+
type ImageProbe,
|
|
19
|
+
probeImageBytes,
|
|
20
|
+
UploadRefusedError,
|
|
21
|
+
} from "../upload-checks";
|
|
22
|
+
import { mimetypeOfFormat } from "../upload-policy";
|
|
23
|
+
import {
|
|
24
|
+
declaredAssetSchema,
|
|
25
|
+
type DeclaredAssetInput,
|
|
26
|
+
declaredFileSizeSchema,
|
|
27
|
+
describeDeclarationIssues,
|
|
28
|
+
} from "../validation/declared.schema";
|
|
29
|
+
import { findBoundFolder, findDeclaredFolder } from "./folders";
|
|
30
|
+
import { waitForTenant, writeWhenReachable } from "./readiness";
|
|
31
|
+
import {
|
|
32
|
+
DECLARED_CONTENT_AUTHOR,
|
|
33
|
+
type DeclaredModels,
|
|
34
|
+
declaredModels,
|
|
35
|
+
hashBytes,
|
|
36
|
+
hashState,
|
|
37
|
+
judgeDeclaredRow,
|
|
38
|
+
judgeMemberChange,
|
|
39
|
+
MediaDeclarationError,
|
|
40
|
+
parseDeclaration,
|
|
41
|
+
saveDeclaration,
|
|
42
|
+
withDeclarationLock,
|
|
43
|
+
} from "./records";
|
|
44
|
+
|
|
45
|
+
/** A declared file, the folder it goes to and the binding whose field that folder feeds. */
|
|
46
|
+
interface AssetTarget {
|
|
47
|
+
models: DeclaredModels;
|
|
48
|
+
declaration: DeclaredAssetInput;
|
|
49
|
+
folder: MediaFolder;
|
|
50
|
+
fieldBinding?: string;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
/** A declared file's bytes, checked against the library's rules. */
|
|
54
|
+
interface PreparedFile {
|
|
55
|
+
bytes: Buffer;
|
|
56
|
+
mimetype: string;
|
|
57
|
+
image: ImageProbe;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
interface AssetHashes {
|
|
61
|
+
declaredHash: string;
|
|
62
|
+
contentHash: string;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
type Fail = (reason: string) => never;
|
|
66
|
+
|
|
67
|
+
/** The member-editable state of a file: its name, folder, alt text, visibility and content. */
|
|
68
|
+
export function assetStateHash(asset: MediaAsset): string {
|
|
69
|
+
return hashState({
|
|
70
|
+
name: asset.name,
|
|
71
|
+
folderId: asset.folderId,
|
|
72
|
+
alt: asset.alt || null,
|
|
73
|
+
visibility: asset.visibility,
|
|
74
|
+
storageKey: asset.storageKey,
|
|
75
|
+
});
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
function assetHashes(
|
|
79
|
+
declaration: DeclaredAssetInput,
|
|
80
|
+
contentHash: string,
|
|
81
|
+
): AssetHashes {
|
|
82
|
+
const declaredHash = hashState({
|
|
83
|
+
name: declaration.name,
|
|
84
|
+
folder: declaration.folder,
|
|
85
|
+
alt: declaration.alt ?? null,
|
|
86
|
+
mimetype: declaration.mimetype,
|
|
87
|
+
content: contentHash,
|
|
88
|
+
});
|
|
89
|
+
return { declaredHash, contentHash };
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
function describeError(error: unknown): string {
|
|
93
|
+
return error instanceof Error ? error.message : String(error);
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
async function loadBytes(
|
|
97
|
+
load: () => Uint8Array | Promise<Uint8Array>,
|
|
98
|
+
fail: Fail,
|
|
99
|
+
): Promise<Buffer> {
|
|
100
|
+
const loaded: unknown = await Promise.resolve()
|
|
101
|
+
.then(load)
|
|
102
|
+
.catch((error: unknown) =>
|
|
103
|
+
fail(`the source failed to load: ${describeError(error)}`),
|
|
104
|
+
);
|
|
105
|
+
if (!(loaded instanceof Uint8Array))
|
|
106
|
+
fail("source.load must return a Uint8Array");
|
|
107
|
+
return Buffer.from(loaded);
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
async function readSource(
|
|
111
|
+
declaration: DeclaredAssetInput,
|
|
112
|
+
fail: Fail,
|
|
113
|
+
): Promise<Buffer> {
|
|
114
|
+
const { source } = declaration;
|
|
115
|
+
let bytes: Buffer;
|
|
116
|
+
if ("bytes" in source) bytes = Buffer.from(source.bytes);
|
|
117
|
+
else if ("filePath" in source)
|
|
118
|
+
bytes = await readFile(source.filePath).catch((error: unknown) =>
|
|
119
|
+
fail(`cannot read '${source.filePath}': ${describeError(error)}`),
|
|
120
|
+
);
|
|
121
|
+
else bytes = await loadBytes(source.load, fail);
|
|
122
|
+
const size = declaredFileSizeSchema.safeParse(bytes.byteLength);
|
|
123
|
+
if (!size.success) fail(describeDeclarationIssues(size.error));
|
|
124
|
+
return bytes;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
/**
|
|
128
|
+
* A declared file's bytes, read at most once and only when a decision needs
|
|
129
|
+
* them: generating or reading content every boot is what `version` and lazy
|
|
130
|
+
* sources let callers avoid.
|
|
131
|
+
*/
|
|
132
|
+
class DeclaredContent {
|
|
133
|
+
private bytes?: Promise<Buffer>;
|
|
134
|
+
|
|
135
|
+
constructor(
|
|
136
|
+
private readonly declaration: DeclaredAssetInput,
|
|
137
|
+
private readonly fail: Fail,
|
|
138
|
+
) {}
|
|
139
|
+
|
|
140
|
+
read(): Promise<Buffer> {
|
|
141
|
+
this.bytes ??= readSource(this.declaration, this.fail);
|
|
142
|
+
return this.bytes;
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
/** The bytes' hash, taken from the last declaration while the caller's version still matches it. */
|
|
146
|
+
async hash(record: MediaDeclaration | undefined): Promise<string> {
|
|
147
|
+
const { version } = this.declaration;
|
|
148
|
+
if (version && record?.contentHash && record.version === version)
|
|
149
|
+
return record.contentHash;
|
|
150
|
+
return hashBytes(await this.read());
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
/** The binding whose field the folder feeds, through its linked ancestors when it has no binding itself. */
|
|
155
|
+
async function fieldBindingOf(
|
|
156
|
+
models: DeclaredModels,
|
|
157
|
+
folder: MediaFolder,
|
|
158
|
+
): Promise<string | undefined> {
|
|
159
|
+
if (folder.binding) return folder.binding;
|
|
160
|
+
const ancestors = await Promise.all(
|
|
161
|
+
folder.path.map((id) => models.folderModel.get(id)),
|
|
162
|
+
);
|
|
163
|
+
const foldersById = new Map(
|
|
164
|
+
ancestors
|
|
165
|
+
.filter((ancestor): ancestor is MediaFolder => ancestor !== undefined)
|
|
166
|
+
.map((ancestor) => [ancestor._id, ancestor]),
|
|
167
|
+
);
|
|
168
|
+
return feedingBinding(folder, foldersById);
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
async function findTargetFolder(
|
|
172
|
+
models: DeclaredModels,
|
|
173
|
+
declaration: DeclaredAssetInput,
|
|
174
|
+
fail: Fail,
|
|
175
|
+
): Promise<MediaFolder | undefined> {
|
|
176
|
+
const target = declaration.folder;
|
|
177
|
+
if ("binding" in target) return findBoundFolder(models, target.binding, fail);
|
|
178
|
+
return (await findDeclaredFolder(models, target.key, fail)).folder;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
/** The checks of the upload routes: type, field type, quota and image decoding. */
|
|
182
|
+
async function prepareFile(
|
|
183
|
+
{ models, declaration, fieldBinding }: AssetTarget,
|
|
184
|
+
bytes: Buffer,
|
|
185
|
+
replacedSize: number,
|
|
186
|
+
): Promise<PreparedFile> {
|
|
187
|
+
assertUploadTypeAllowed(fieldBinding, declaration.name, declaration.mimetype);
|
|
188
|
+
await assertWithinQuota(
|
|
189
|
+
models.assetModel,
|
|
190
|
+
Math.max(bytes.byteLength - replacedSize, 0),
|
|
191
|
+
);
|
|
192
|
+
const image = await probeImageBytes(
|
|
193
|
+
async () => bytes,
|
|
194
|
+
declaration.mimetype,
|
|
195
|
+
bytes.byteLength,
|
|
196
|
+
);
|
|
197
|
+
assertReadableImage(image, declaration.mimetype);
|
|
198
|
+
return {
|
|
199
|
+
bytes,
|
|
200
|
+
mimetype: mimetypeOfFormat(image.format) ?? declaration.mimetype,
|
|
201
|
+
image,
|
|
202
|
+
};
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
function writeFile(
|
|
206
|
+
{ models, declaration, folder }: AssetTarget,
|
|
207
|
+
file: PreparedFile,
|
|
208
|
+
): Promise<string> {
|
|
209
|
+
return writeWhenReachable(() =>
|
|
210
|
+
uploadStorageBytes(
|
|
211
|
+
file.bytes,
|
|
212
|
+
declaration.name,
|
|
213
|
+
file.mimetype,
|
|
214
|
+
`media/${models.tenantId}/${folder._id}`,
|
|
215
|
+
getMediaConfig().storage,
|
|
216
|
+
),
|
|
217
|
+
);
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
async function insertAsset(
|
|
221
|
+
{ models, declaration, folder }: AssetTarget,
|
|
222
|
+
file: PreparedFile,
|
|
223
|
+
storageKey: string,
|
|
224
|
+
): Promise<MediaAsset | undefined> {
|
|
225
|
+
const [assetId] = await models.assetModel.insert({
|
|
226
|
+
folderId: folder._id,
|
|
227
|
+
mediaRevision: randomUUID(),
|
|
228
|
+
json_retiredFiles: "[]",
|
|
229
|
+
name: declaration.name,
|
|
230
|
+
mimetype: file.mimetype,
|
|
231
|
+
size: file.bytes.byteLength,
|
|
232
|
+
storageKey,
|
|
233
|
+
storage: getMediaConfig().storage,
|
|
234
|
+
width: file.image.width,
|
|
235
|
+
height: file.image.height,
|
|
236
|
+
alt: declaration.alt,
|
|
237
|
+
visibility: "inherit",
|
|
238
|
+
createdBy: DECLARED_CONTENT_AUTHOR._id,
|
|
239
|
+
});
|
|
240
|
+
return models.assetModel.get(assetId);
|
|
241
|
+
}
|
|
242
|
+
|
|
243
|
+
async function createAsset(
|
|
244
|
+
target: AssetTarget,
|
|
245
|
+
file: PreparedFile,
|
|
246
|
+
): Promise<MediaAsset> {
|
|
247
|
+
const storageKey = await writeFile(target, file);
|
|
248
|
+
const discardFile = () =>
|
|
249
|
+
DeleteFile(storageKey, getMediaConfig().storage).catch(() => undefined);
|
|
250
|
+
const asset = await insertAsset(target, file, storageKey).catch(
|
|
251
|
+
async (error: unknown) => {
|
|
252
|
+
await discardFile();
|
|
253
|
+
throw error;
|
|
254
|
+
},
|
|
255
|
+
);
|
|
256
|
+
if (!asset) {
|
|
257
|
+
await discardFile();
|
|
258
|
+
throw new MediaDeclarationError(
|
|
259
|
+
"asset",
|
|
260
|
+
target.declaration.key,
|
|
261
|
+
"the file could not be created",
|
|
262
|
+
);
|
|
263
|
+
}
|
|
264
|
+
await recordMediaEvent(
|
|
265
|
+
{ tenantId: target.models.tenantId, user: DECLARED_CONTENT_AUTHOR },
|
|
266
|
+
{
|
|
267
|
+
kind: "asset.upload",
|
|
268
|
+
targetName: asset.name,
|
|
269
|
+
folderId: asset.folderId,
|
|
270
|
+
assetId: asset._id,
|
|
271
|
+
size: asset.size,
|
|
272
|
+
},
|
|
273
|
+
);
|
|
274
|
+
return asset;
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
/** Publishes metadata and optional new bytes together, only while the file is untouched. */
|
|
278
|
+
async function refreshAsset(
|
|
279
|
+
target: AssetTarget,
|
|
280
|
+
asset: MediaAsset,
|
|
281
|
+
content: DeclaredContent,
|
|
282
|
+
isContentChanged: boolean,
|
|
283
|
+
): Promise<MediaAsset | undefined> {
|
|
284
|
+
const { models, declaration, folder, fieldBinding } = target;
|
|
285
|
+
const { assetModel } = models;
|
|
286
|
+
const patch: Partial<MediaAsset> = {
|
|
287
|
+
name: declaration.name,
|
|
288
|
+
folderId: folder._id,
|
|
289
|
+
alt: declaration.alt ?? "",
|
|
290
|
+
};
|
|
291
|
+
let storageKey: string | undefined;
|
|
292
|
+
if (isContentChanged) {
|
|
293
|
+
const file = await prepareFile(target, await content.read(), asset.size);
|
|
294
|
+
storageKey = await writeFile(target, file);
|
|
295
|
+
Object.assign(patch, {
|
|
296
|
+
storageKey,
|
|
297
|
+
mimetype: file.mimetype,
|
|
298
|
+
size: file.bytes.byteLength,
|
|
299
|
+
width: file.image.width,
|
|
300
|
+
height: file.image.height,
|
|
301
|
+
json_derivatives: "",
|
|
302
|
+
});
|
|
303
|
+
} else {
|
|
304
|
+
assertUploadTypeAllowed(fieldBinding, declaration.name, asset.mimetype);
|
|
305
|
+
}
|
|
306
|
+
for (;;) {
|
|
307
|
+
const fresh = await assetModel.get(asset._id);
|
|
308
|
+
const isStillAsDeclared =
|
|
309
|
+
fresh !== undefined &&
|
|
310
|
+
!fresh.isDeleting &&
|
|
311
|
+
assetStateHash(fresh) === assetStateHash(asset);
|
|
312
|
+
if (!isStillAsDeclared) {
|
|
313
|
+
if (storageKey)
|
|
314
|
+
await DeleteFile(storageKey, getMediaConfig().storage).catch(
|
|
315
|
+
() => undefined,
|
|
316
|
+
);
|
|
317
|
+
return undefined;
|
|
318
|
+
}
|
|
319
|
+
if (
|
|
320
|
+
await updateAssetMedia(assetModel, fresh, patch, {
|
|
321
|
+
preserveDetails: true,
|
|
322
|
+
})
|
|
323
|
+
)
|
|
324
|
+
break;
|
|
325
|
+
}
|
|
326
|
+
if (storageKey) await cleanupAssetFiles(assetModel, asset._id);
|
|
327
|
+
// A concurrent edit after publication must not become our new baseline.
|
|
328
|
+
return Object.assign(asset, patch);
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
function rememberAsset(
|
|
332
|
+
target: AssetTarget,
|
|
333
|
+
record: MediaDeclaration | undefined,
|
|
334
|
+
asset: MediaAsset,
|
|
335
|
+
hashes: AssetHashes,
|
|
336
|
+
): Promise<void> {
|
|
337
|
+
return saveDeclaration(target.models.declarationModel, record, {
|
|
338
|
+
kind: "asset",
|
|
339
|
+
key: target.declaration.key,
|
|
340
|
+
targetId: asset._id,
|
|
341
|
+
appliedHash: assetStateHash(asset),
|
|
342
|
+
version: target.declaration.version ?? "",
|
|
343
|
+
...hashes,
|
|
344
|
+
});
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
/** Remembers a new caller version of unchanged bytes, so the next boot does not read them again. */
|
|
348
|
+
async function rememberVersion(
|
|
349
|
+
models: DeclaredModels,
|
|
350
|
+
record: MediaDeclaration,
|
|
351
|
+
version: string | undefined,
|
|
352
|
+
): Promise<void> {
|
|
353
|
+
if (!version || record.version === version) return;
|
|
354
|
+
await models.declarationModel.update(record._id, { version });
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
async function applyAssetDeclaration(
|
|
358
|
+
declaration: DeclaredAssetInput,
|
|
359
|
+
): Promise<MediaDeclarationResult> {
|
|
360
|
+
const fail: Fail = (reason) => {
|
|
361
|
+
throw new MediaDeclarationError("asset", declaration.key, reason);
|
|
362
|
+
};
|
|
363
|
+
const content = new DeclaredContent(declaration, fail);
|
|
364
|
+
await waitForTenant(declaration.tenantId);
|
|
365
|
+
const models = declaredModels(declaration.tenantId);
|
|
366
|
+
const record = await models.declarationModel.findByKey(
|
|
367
|
+
"asset",
|
|
368
|
+
declaration.key,
|
|
369
|
+
);
|
|
370
|
+
const stored = record && (await models.assetModel.get(record.targetId));
|
|
371
|
+
const asset = stored && !stored.isDeleting ? stored : undefined;
|
|
372
|
+
// Deleted or changed by a member: the new content cannot matter, so it is not read.
|
|
373
|
+
const change =
|
|
374
|
+
record && judgeMemberChange(record, asset, asset && assetStateHash(asset));
|
|
375
|
+
if (change) return change;
|
|
376
|
+
const hashes = assetHashes(declaration, await content.hash(record));
|
|
377
|
+
const verdict =
|
|
378
|
+
record &&
|
|
379
|
+
judgeDeclaredRow(
|
|
380
|
+
record,
|
|
381
|
+
asset,
|
|
382
|
+
asset && assetStateHash(asset),
|
|
383
|
+
hashes.declaredHash,
|
|
384
|
+
);
|
|
385
|
+
if (verdict) {
|
|
386
|
+
if (record) await rememberVersion(models, record, declaration.version);
|
|
387
|
+
return verdict;
|
|
388
|
+
}
|
|
389
|
+
const folder = await findTargetFolder(models, declaration, fail);
|
|
390
|
+
// A file whose declared folder a member deleted went with it, or never came.
|
|
391
|
+
if (!folder)
|
|
392
|
+
return asset
|
|
393
|
+
? { status: "preserved", id: asset._id }
|
|
394
|
+
: { status: "deleted" };
|
|
395
|
+
const target: AssetTarget = {
|
|
396
|
+
models,
|
|
397
|
+
declaration,
|
|
398
|
+
folder,
|
|
399
|
+
fieldBinding: await fieldBindingOf(models, folder),
|
|
400
|
+
};
|
|
401
|
+
if (!record || !asset) {
|
|
402
|
+
const file = await prepareFile(target, await content.read(), 0);
|
|
403
|
+
const created = await createAsset(target, file);
|
|
404
|
+
await rememberAsset(target, record, created, hashes);
|
|
405
|
+
return { status: "created", id: created._id };
|
|
406
|
+
}
|
|
407
|
+
const isContentChanged = record.contentHash !== hashes.contentHash;
|
|
408
|
+
const refreshed = await refreshAsset(
|
|
409
|
+
target,
|
|
410
|
+
asset,
|
|
411
|
+
content,
|
|
412
|
+
isContentChanged,
|
|
413
|
+
);
|
|
414
|
+
if (!refreshed) {
|
|
415
|
+
const current = await models.assetModel.get(asset._id);
|
|
416
|
+
return current && !current.isDeleting
|
|
417
|
+
? { status: "preserved", id: asset._id }
|
|
418
|
+
: { status: "deleted" };
|
|
419
|
+
}
|
|
420
|
+
await rememberAsset(target, record, refreshed, hashes);
|
|
421
|
+
return { status: "updated", id: refreshed._id };
|
|
422
|
+
}
|
|
423
|
+
|
|
424
|
+
/** Implements `ImportMediaAsset`. */
|
|
425
|
+
export async function importDeclaredAsset(
|
|
426
|
+
input: MediaAssetDeclaration,
|
|
427
|
+
): Promise<MediaDeclarationResult> {
|
|
428
|
+
const declaration = parseDeclaration("asset", input, declaredAssetSchema);
|
|
429
|
+
return withDeclarationLock(
|
|
430
|
+
declaration.tenantId,
|
|
431
|
+
"asset",
|
|
432
|
+
declaration.key,
|
|
433
|
+
async () => {
|
|
434
|
+
try {
|
|
435
|
+
return await applyAssetDeclaration(declaration);
|
|
436
|
+
} catch (error) {
|
|
437
|
+
if (!(error instanceof UploadRefusedError)) throw error;
|
|
438
|
+
throw new MediaDeclarationError(
|
|
439
|
+
"asset",
|
|
440
|
+
declaration.key,
|
|
441
|
+
error.message,
|
|
442
|
+
);
|
|
443
|
+
}
|
|
444
|
+
},
|
|
445
|
+
);
|
|
446
|
+
}
|
|
@@ -0,0 +1,273 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
MediaDeclarationResult,
|
|
3
|
+
MediaFolderDeclaration,
|
|
4
|
+
} from "@antelopejs/interface-dms-media";
|
|
5
|
+
import { serializeAcl } from "../acl";
|
|
6
|
+
import { bindingHoldsSubfolders, ensureTenantBindings } from "../bindings";
|
|
7
|
+
import type { MediaDeclaration, MediaFolder } from "../db";
|
|
8
|
+
import { recordMediaEvent } from "../library/events";
|
|
9
|
+
import {
|
|
10
|
+
buildChildPath,
|
|
11
|
+
hasSiblingNamed,
|
|
12
|
+
isMoveInsideSubtree,
|
|
13
|
+
rewriteDescendantPaths,
|
|
14
|
+
} from "../routes/media/folders";
|
|
15
|
+
import {
|
|
16
|
+
declaredFolderSchema,
|
|
17
|
+
type DeclaredFolderInput,
|
|
18
|
+
} from "../validation/declared.schema";
|
|
19
|
+
import { waitForTenant } from "./readiness";
|
|
20
|
+
import {
|
|
21
|
+
DECLARED_CONTENT_AUTHOR,
|
|
22
|
+
type DeclaredModels,
|
|
23
|
+
declaredModels,
|
|
24
|
+
hashState,
|
|
25
|
+
judgeDeclaredRow,
|
|
26
|
+
MediaDeclarationError,
|
|
27
|
+
parseDeclaration,
|
|
28
|
+
saveDeclaration,
|
|
29
|
+
settlePendingDeclaration,
|
|
30
|
+
withDeclarationLock,
|
|
31
|
+
} from "./records";
|
|
32
|
+
|
|
33
|
+
/** A declared folder looked up by key: absent when a member deleted it. */
|
|
34
|
+
export interface DeclaredFolderLookup {
|
|
35
|
+
folder?: MediaFolder;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
/** The member-editable state of a folder: its name, place, visibility and ACL. */
|
|
39
|
+
export function folderStateHash(folder: MediaFolder): string {
|
|
40
|
+
return hashState({
|
|
41
|
+
name: folder.name,
|
|
42
|
+
parentId: folder.parentId || null,
|
|
43
|
+
visibility: folder.visibility,
|
|
44
|
+
acl: folder.json_acl || null,
|
|
45
|
+
});
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
type ParentTarget = NonNullable<DeclaredFolderInput["parent"]>;
|
|
49
|
+
|
|
50
|
+
/** The declared folder key a parent names, written as a string or as `{ key }`. */
|
|
51
|
+
function parentKeyOf(parent: ParentTarget | undefined): string | undefined {
|
|
52
|
+
if (typeof parent === "string") return parent;
|
|
53
|
+
return parent && "key" in parent ? parent.key : undefined;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
function folderDeclarationHash(declaration: DeclaredFolderInput): string {
|
|
57
|
+
const { parent } = declaration;
|
|
58
|
+
return hashState({
|
|
59
|
+
name: declaration.name,
|
|
60
|
+
// Both spellings of a declared parent hash alike: switching between them changes nothing.
|
|
61
|
+
parent: parentKeyOf(parent) ?? parent ?? null,
|
|
62
|
+
visibility: declaration.visibility,
|
|
63
|
+
acl: declaration.acl ?? null,
|
|
64
|
+
});
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
/**
|
|
68
|
+
* The folder declared under `key`. Throws when no module ever declared it,
|
|
69
|
+
* since that is a mistake in the calling code rather than a member's change.
|
|
70
|
+
*/
|
|
71
|
+
export async function findDeclaredFolder(
|
|
72
|
+
models: DeclaredModels,
|
|
73
|
+
key: string,
|
|
74
|
+
onUnknown: (reason: string) => never,
|
|
75
|
+
): Promise<DeclaredFolderLookup> {
|
|
76
|
+
await settlePendingDeclaration(models.tenantId, "folder", key);
|
|
77
|
+
const record = await models.declarationModel.findByKey("folder", key);
|
|
78
|
+
if (!record)
|
|
79
|
+
onUnknown(
|
|
80
|
+
`'${key}' is not a declared folder: declare it with EnsureMediaFolder first`,
|
|
81
|
+
);
|
|
82
|
+
return { folder: await models.folderModel.get(record.targetId) };
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/** The folder bound to an asset field, provisioned like the dashboard does. */
|
|
86
|
+
export async function findBoundFolder(
|
|
87
|
+
models: DeclaredModels,
|
|
88
|
+
binding: string,
|
|
89
|
+
fail: (reason: string) => never,
|
|
90
|
+
): Promise<MediaFolder> {
|
|
91
|
+
await ensureTenantBindings(models.tenantId, models.folderModel);
|
|
92
|
+
const folder = await models.folderModel.getByBinding(binding);
|
|
93
|
+
if (!folder)
|
|
94
|
+
fail(
|
|
95
|
+
`no folder is bound to '${binding}': register the binding with AssetType or RegisterAssetBinding first`,
|
|
96
|
+
);
|
|
97
|
+
return folder;
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
async function findParentFolder(
|
|
101
|
+
models: DeclaredModels,
|
|
102
|
+
parent: ParentTarget,
|
|
103
|
+
fail: (reason: string) => never,
|
|
104
|
+
): Promise<DeclaredFolderLookup> {
|
|
105
|
+
if (typeof parent === "string")
|
|
106
|
+
return findDeclaredFolder(models, parent, fail);
|
|
107
|
+
if ("key" in parent) return findDeclaredFolder(models, parent.key, fail);
|
|
108
|
+
const { binding } = parent;
|
|
109
|
+
const folder = await findBoundFolder(models, binding, fail);
|
|
110
|
+
if (!bindingHoldsSubfolders(binding))
|
|
111
|
+
fail(
|
|
112
|
+
`the folder linked to '${binding}' cannot hold subfolders: register its binding with subfolders: true`,
|
|
113
|
+
);
|
|
114
|
+
return { folder };
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
async function createFolder(
|
|
118
|
+
models: DeclaredModels,
|
|
119
|
+
declaration: DeclaredFolderInput,
|
|
120
|
+
parent: MediaFolder | undefined,
|
|
121
|
+
): Promise<MediaFolder> {
|
|
122
|
+
const folders = await models.folderModel.getAll();
|
|
123
|
+
if (hasSiblingNamed(folders, declaration.name, parent?._id))
|
|
124
|
+
throw new MediaDeclarationError(
|
|
125
|
+
"folder",
|
|
126
|
+
declaration.key,
|
|
127
|
+
`a folder named '${declaration.name}' already exists there`,
|
|
128
|
+
);
|
|
129
|
+
const [folderId] = await models.folderModel.insert({
|
|
130
|
+
name: declaration.name,
|
|
131
|
+
parentId: parent?._id,
|
|
132
|
+
path: buildChildPath(parent),
|
|
133
|
+
visibility: declaration.visibility,
|
|
134
|
+
json_acl: serializeAcl(declaration.acl),
|
|
135
|
+
});
|
|
136
|
+
const folder = await models.folderModel.get(folderId);
|
|
137
|
+
if (!folder)
|
|
138
|
+
throw new MediaDeclarationError(
|
|
139
|
+
"folder",
|
|
140
|
+
declaration.key,
|
|
141
|
+
"the folder could not be created",
|
|
142
|
+
);
|
|
143
|
+
await recordMediaEvent(
|
|
144
|
+
{ tenantId: models.tenantId, user: DECLARED_CONTENT_AUTHOR },
|
|
145
|
+
{
|
|
146
|
+
kind: "folder.create",
|
|
147
|
+
targetName: folder.name,
|
|
148
|
+
folderId: parent?._id,
|
|
149
|
+
details: { targetId: folder._id },
|
|
150
|
+
},
|
|
151
|
+
);
|
|
152
|
+
return folder;
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
async function refreshFolder(
|
|
156
|
+
models: DeclaredModels,
|
|
157
|
+
declaration: DeclaredFolderInput,
|
|
158
|
+
folder: MediaFolder,
|
|
159
|
+
parent: MediaFolder | undefined,
|
|
160
|
+
): Promise<MediaFolder | undefined> {
|
|
161
|
+
if (isMoveInsideSubtree(folder, parent))
|
|
162
|
+
throw new MediaDeclarationError(
|
|
163
|
+
"folder",
|
|
164
|
+
declaration.key,
|
|
165
|
+
"Cannot move a folder inside itself",
|
|
166
|
+
);
|
|
167
|
+
const folders = await models.folderModel.getAll();
|
|
168
|
+
if (hasSiblingNamed(folders, declaration.name, parent?._id, folder._id))
|
|
169
|
+
throw new MediaDeclarationError(
|
|
170
|
+
"folder",
|
|
171
|
+
declaration.key,
|
|
172
|
+
`a folder named '${declaration.name}' already exists there`,
|
|
173
|
+
);
|
|
174
|
+
// An empty ACL string reads as no ACL: the folder inherits its parent's.
|
|
175
|
+
const patch: Partial<MediaFolder> = {
|
|
176
|
+
name: declaration.name,
|
|
177
|
+
parentId: parent?._id,
|
|
178
|
+
path: buildChildPath(parent),
|
|
179
|
+
visibility: declaration.visibility,
|
|
180
|
+
json_acl: serializeAcl(declaration.acl) ?? "",
|
|
181
|
+
};
|
|
182
|
+
if (!(await models.folderModel.compareDeclared(folder, patch)))
|
|
183
|
+
return undefined;
|
|
184
|
+
if ((folder.parentId || undefined) !== parent?._id) {
|
|
185
|
+
await rewriteDescendantPaths(
|
|
186
|
+
{ folderModel: models.folderModel, folders },
|
|
187
|
+
folder,
|
|
188
|
+
patch.path ?? [],
|
|
189
|
+
);
|
|
190
|
+
}
|
|
191
|
+
// Remember only our write, not a member's edit made just after it.
|
|
192
|
+
return Object.assign(folder, patch);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
async function applyFolderDeclaration(
|
|
196
|
+
declaration: DeclaredFolderInput,
|
|
197
|
+
): Promise<MediaDeclarationResult> {
|
|
198
|
+
await waitForTenant(declaration.tenantId);
|
|
199
|
+
const models = declaredModels(declaration.tenantId);
|
|
200
|
+
const fail = (reason: string): never => {
|
|
201
|
+
throw new MediaDeclarationError("folder", declaration.key, reason);
|
|
202
|
+
};
|
|
203
|
+
const parentLookup = declaration.parent
|
|
204
|
+
? await findParentFolder(models, declaration.parent, fail)
|
|
205
|
+
: undefined;
|
|
206
|
+
const parent = parentLookup?.folder;
|
|
207
|
+
const isParentDeleted = Boolean(parentLookup) && !parent;
|
|
208
|
+
const record = await models.declarationModel.findByKey(
|
|
209
|
+
"folder",
|
|
210
|
+
declaration.key,
|
|
211
|
+
);
|
|
212
|
+
const declaredHash = folderDeclarationHash(declaration);
|
|
213
|
+
if (!record) {
|
|
214
|
+
// The parent a member deleted takes its declared children with it.
|
|
215
|
+
if (isParentDeleted) return { status: "deleted" };
|
|
216
|
+
const folder = await createFolder(models, declaration, parent);
|
|
217
|
+
await rememberFolder(models, undefined, declaration, folder, declaredHash);
|
|
218
|
+
return { status: "created", id: folder._id };
|
|
219
|
+
}
|
|
220
|
+
const folder = await models.folderModel.get(record.targetId);
|
|
221
|
+
const verdict = judgeDeclaredRow(
|
|
222
|
+
record,
|
|
223
|
+
folder,
|
|
224
|
+
folder && folderStateHash(folder),
|
|
225
|
+
declaredHash,
|
|
226
|
+
);
|
|
227
|
+
if (verdict || !folder) return verdict ?? { status: "deleted" };
|
|
228
|
+
if (isParentDeleted) return { status: "preserved", id: folder._id };
|
|
229
|
+
const refreshed = await refreshFolder(models, declaration, folder, parent);
|
|
230
|
+
if (!refreshed) {
|
|
231
|
+
const current = await models.folderModel.get(folder._id);
|
|
232
|
+
return current
|
|
233
|
+
? { status: "preserved", id: folder._id }
|
|
234
|
+
: { status: "deleted" };
|
|
235
|
+
}
|
|
236
|
+
await rememberFolder(models, record, declaration, refreshed, declaredHash);
|
|
237
|
+
return { status: "updated", id: refreshed._id };
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
function rememberFolder(
|
|
241
|
+
models: DeclaredModels,
|
|
242
|
+
record: MediaDeclaration | undefined,
|
|
243
|
+
declaration: DeclaredFolderInput,
|
|
244
|
+
folder: MediaFolder,
|
|
245
|
+
declaredHash: string,
|
|
246
|
+
): Promise<void> {
|
|
247
|
+
return saveDeclaration(models.declarationModel, record, {
|
|
248
|
+
kind: "folder",
|
|
249
|
+
key: declaration.key,
|
|
250
|
+
targetId: folder._id,
|
|
251
|
+
declaredHash,
|
|
252
|
+
appliedHash: folderStateHash(folder),
|
|
253
|
+
});
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
/** Implements `EnsureMediaFolder`. */
|
|
257
|
+
export async function ensureDeclaredFolder(
|
|
258
|
+
input: MediaFolderDeclaration,
|
|
259
|
+
): Promise<MediaDeclarationResult> {
|
|
260
|
+
const declaration = parseDeclaration("folder", input, declaredFolderSchema);
|
|
261
|
+
if (parentKeyOf(declaration.parent) === declaration.key)
|
|
262
|
+
throw new MediaDeclarationError(
|
|
263
|
+
"folder",
|
|
264
|
+
declaration.key,
|
|
265
|
+
"a folder cannot be its own parent",
|
|
266
|
+
);
|
|
267
|
+
return withDeclarationLock(
|
|
268
|
+
declaration.tenantId,
|
|
269
|
+
"folder",
|
|
270
|
+
declaration.key,
|
|
271
|
+
() => applyFolderDeclaration(declaration),
|
|
272
|
+
);
|
|
273
|
+
}
|