@antelopejs/dms-media 0.4.0 → 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 +58 -184
- 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 +2 -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/mediaEvents.model.d.ts +1 -0
- package/dist/db/models/mediaFavorites.model.d.ts +1 -0
- package/dist/db/models/mediaFolders.model.d.ts +4 -0
- package/dist/db/models/mediaFolders.model.js +29 -0
- package/dist/db/models/mediaFolders.model.js.map +1 -1
- package/dist/db/models/mediaUploads.model.d.ts +1 -0
- 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/antelope.test.js +5 -5
- 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/ImageEditor.vue +2 -2
- 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/package.json +1 -1
- package/frontend-vue/tests/serverRender.test.ts +2 -1
- package/package.json +33 -15
- package/skills/dms-media/SKILL.md +110 -0
- 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/antelope.test.ts +5 -5
- 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,844 @@
|
|
|
1
|
+
import { mkdtemp, rm, writeFile } from "node:fs/promises";
|
|
2
|
+
import { tmpdir } from "node:os";
|
|
3
|
+
import { join } from "node:path";
|
|
4
|
+
import { Schema } from "@antelopejs/interface-database";
|
|
5
|
+
import { GetModel } from "@antelopejs/interface-database-decorators";
|
|
6
|
+
import {
|
|
7
|
+
DEFAULT_TENANT_ID,
|
|
8
|
+
TENANT_SCHEMA_NAME,
|
|
9
|
+
} from "@antelopejs/interface-dms/constants";
|
|
10
|
+
import {
|
|
11
|
+
EnsureMediaFolder,
|
|
12
|
+
ImportMediaAsset,
|
|
13
|
+
RegisterAssetBinding,
|
|
14
|
+
} from "@antelopejs/interface-dms-media";
|
|
15
|
+
import type { AxiosInstance } from "axios";
|
|
16
|
+
import { expect } from "chai";
|
|
17
|
+
import sharp from "sharp";
|
|
18
|
+
import {
|
|
19
|
+
MediaAssetModel,
|
|
20
|
+
MediaDeclarationModel,
|
|
21
|
+
MediaEventModel,
|
|
22
|
+
MediaFolderModel,
|
|
23
|
+
} from "../../db";
|
|
24
|
+
import { ONE_PIXEL_PNG, PNG_MIMETYPE } from "../helpers/assets";
|
|
25
|
+
import { readFolderAcl } from "../helpers/folders";
|
|
26
|
+
import { authorizedClient } from "../helpers/http";
|
|
27
|
+
import { ensureOwnerSession } from "../helpers/owner";
|
|
28
|
+
|
|
29
|
+
const HTTP_OK = 200;
|
|
30
|
+
const BINDING_ID = "declared.covers";
|
|
31
|
+
const ROOT_KEY = "declared.procedures";
|
|
32
|
+
const CHILD_KEY = "declared.procedures.safety";
|
|
33
|
+
const ACL = [
|
|
34
|
+
{
|
|
35
|
+
subject: { kind: "permission" as const, id: "declared.page" },
|
|
36
|
+
rights: ["read" as const],
|
|
37
|
+
},
|
|
38
|
+
];
|
|
39
|
+
|
|
40
|
+
function folders() {
|
|
41
|
+
return GetModel(MediaFolderModel, DEFAULT_TENANT_ID);
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
function assets() {
|
|
45
|
+
return GetModel(MediaAssetModel, DEFAULT_TENANT_ID);
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
async function rejectionOf(promise: Promise<unknown>): Promise<Error> {
|
|
49
|
+
try {
|
|
50
|
+
await promise;
|
|
51
|
+
} catch (error) {
|
|
52
|
+
return error as Error;
|
|
53
|
+
}
|
|
54
|
+
throw new Error("Expected the declaration to be refused");
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
function squarePng(size: number): Promise<Buffer> {
|
|
58
|
+
return sharp({
|
|
59
|
+
create: {
|
|
60
|
+
width: size,
|
|
61
|
+
height: size,
|
|
62
|
+
channels: 3,
|
|
63
|
+
background: { r: 240, g: 160, b: 0 },
|
|
64
|
+
},
|
|
65
|
+
})
|
|
66
|
+
.png()
|
|
67
|
+
.toBuffer();
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
describe("[integration] media declared content — folders and files shipped as code", () => {
|
|
71
|
+
let client: AxiosInstance;
|
|
72
|
+
let tempDir: string;
|
|
73
|
+
|
|
74
|
+
before(async function () {
|
|
75
|
+
this.timeout(40_000);
|
|
76
|
+
RegisterAssetBinding({
|
|
77
|
+
id: BINDING_ID,
|
|
78
|
+
folderName: "Declared covers",
|
|
79
|
+
field: { mimetypes: ["image/*"] },
|
|
80
|
+
});
|
|
81
|
+
const session = await ensureOwnerSession();
|
|
82
|
+
client = authorizedClient(session.accessToken);
|
|
83
|
+
tempDir = await mkdtemp(join(tmpdir(), "dms-media-declared-"));
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
after(async () => {
|
|
87
|
+
await rm(tempDir, { recursive: true, force: true });
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
it("rejects missing or blank tenants before changing the default library", async () => {
|
|
91
|
+
const declarationModel = GetModel(MediaDeclarationModel, DEFAULT_TENANT_ID);
|
|
92
|
+
const eventModel = GetModel(MediaEventModel, DEFAULT_TENANT_ID);
|
|
93
|
+
const before = {
|
|
94
|
+
folders: await folders().getAll(),
|
|
95
|
+
assets: await assets().getAll(),
|
|
96
|
+
declarations: await declarationModel.getAll(),
|
|
97
|
+
events: await eventModel.getAll(),
|
|
98
|
+
};
|
|
99
|
+
const folder = {
|
|
100
|
+
key: "declared.invalid-tenant",
|
|
101
|
+
name: "No implicit tenant",
|
|
102
|
+
};
|
|
103
|
+
const file = {
|
|
104
|
+
key: "declared.invalid-tenant-file",
|
|
105
|
+
folder: { binding: BINDING_ID },
|
|
106
|
+
name: "invalid-tenant.png",
|
|
107
|
+
mimetype: PNG_MIMETYPE,
|
|
108
|
+
source: { bytes: ONE_PIXEL_PNG },
|
|
109
|
+
};
|
|
110
|
+
// These calls also fail compilation if the public contract becomes optional.
|
|
111
|
+
// @ts-expect-error A JavaScript caller can omit the required tenantId.
|
|
112
|
+
expect((await rejectionOf(EnsureMediaFolder(folder))).message).to.contain(
|
|
113
|
+
"tenantId",
|
|
114
|
+
);
|
|
115
|
+
// @ts-expect-error A JavaScript caller can omit the required tenantId.
|
|
116
|
+
expect((await rejectionOf(ImportMediaAsset(file))).message).to.contain(
|
|
117
|
+
"tenantId",
|
|
118
|
+
);
|
|
119
|
+
for (const tenantId of ["", " \t\n "]) {
|
|
120
|
+
expect(
|
|
121
|
+
(await rejectionOf(EnsureMediaFolder({ ...folder, tenantId }))).message,
|
|
122
|
+
).to.contain("tenantId");
|
|
123
|
+
expect(
|
|
124
|
+
(await rejectionOf(ImportMediaAsset({ ...file, tenantId }))).message,
|
|
125
|
+
).to.contain("tenantId");
|
|
126
|
+
}
|
|
127
|
+
// Validation also precedes source reads, not only the final database write.
|
|
128
|
+
expect(
|
|
129
|
+
(
|
|
130
|
+
await rejectionOf(
|
|
131
|
+
ImportMediaAsset({
|
|
132
|
+
...file,
|
|
133
|
+
tenantId: "",
|
|
134
|
+
source: { filePath: join(tempDir, "does-not-exist.png") },
|
|
135
|
+
}),
|
|
136
|
+
)
|
|
137
|
+
).message,
|
|
138
|
+
).to.contain("tenantId");
|
|
139
|
+
expect({
|
|
140
|
+
folders: await folders().getAll(),
|
|
141
|
+
assets: await assets().getAll(),
|
|
142
|
+
declarations: await declarationModel.getAll(),
|
|
143
|
+
events: await eventModel.getAll(),
|
|
144
|
+
}).to.deep.equal(before);
|
|
145
|
+
});
|
|
146
|
+
|
|
147
|
+
it("isolates the same declaration keys and updates in two tenant instances", async () => {
|
|
148
|
+
const tenantId = "declared-isolation";
|
|
149
|
+
const schema = Schema.get(TENANT_SCHEMA_NAME);
|
|
150
|
+
if (!schema) throw new Error("Tenant schema is missing");
|
|
151
|
+
// Disposable database fixture, not a change to workspace provisioning.
|
|
152
|
+
await schema.createInstance(tenantId).run();
|
|
153
|
+
try {
|
|
154
|
+
const folder = {
|
|
155
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
156
|
+
key: "declared.isolated",
|
|
157
|
+
name: "Isolated",
|
|
158
|
+
};
|
|
159
|
+
const firstFolder = await EnsureMediaFolder(folder);
|
|
160
|
+
const secondFolder = await EnsureMediaFolder({ ...folder, tenantId });
|
|
161
|
+
expect(firstFolder.id).to.not.equal(secondFolder.id);
|
|
162
|
+
const file = {
|
|
163
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
164
|
+
key: folder.key,
|
|
165
|
+
folder: { key: folder.key },
|
|
166
|
+
name: "isolated.txt",
|
|
167
|
+
mimetype: "text/plain",
|
|
168
|
+
source: { bytes: Buffer.from("Initial") },
|
|
169
|
+
};
|
|
170
|
+
const firstFile = await ImportMediaAsset(file);
|
|
171
|
+
const secondFile = await ImportMediaAsset({ ...file, tenantId });
|
|
172
|
+
expect(firstFile.id).to.not.equal(secondFile.id);
|
|
173
|
+
expect(
|
|
174
|
+
(
|
|
175
|
+
await EnsureMediaFolder({
|
|
176
|
+
...folder,
|
|
177
|
+
tenantId,
|
|
178
|
+
name: "Other tenant folder",
|
|
179
|
+
})
|
|
180
|
+
).status,
|
|
181
|
+
).to.equal("updated");
|
|
182
|
+
expect(
|
|
183
|
+
(
|
|
184
|
+
await ImportMediaAsset({
|
|
185
|
+
...file,
|
|
186
|
+
tenantId,
|
|
187
|
+
source: { bytes: Buffer.from("Other tenant content") },
|
|
188
|
+
})
|
|
189
|
+
).status,
|
|
190
|
+
).to.equal("updated");
|
|
191
|
+
expect((await EnsureMediaFolder(folder)).status).to.equal("unchanged");
|
|
192
|
+
expect((await ImportMediaAsset(file)).status).to.equal("unchanged");
|
|
193
|
+
expect(
|
|
194
|
+
await GetModel(MediaAssetModel, tenantId).get(firstFile.id as string),
|
|
195
|
+
).to.equal(undefined);
|
|
196
|
+
expect(await assets().get(secondFile.id as string)).to.equal(undefined);
|
|
197
|
+
} finally {
|
|
198
|
+
await schema.destroyInstance(tenantId).run();
|
|
199
|
+
}
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
describe("folders", () => {
|
|
203
|
+
it("rejects self-parenting without blocking later declarations of the key", async () => {
|
|
204
|
+
const key = "declared.self-parent";
|
|
205
|
+
let timeout: ReturnType<typeof setTimeout> | undefined;
|
|
206
|
+
try {
|
|
207
|
+
const error = await rejectionOf(
|
|
208
|
+
Promise.race([
|
|
209
|
+
EnsureMediaFolder({
|
|
210
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
211
|
+
key,
|
|
212
|
+
name: "Self",
|
|
213
|
+
parent: key,
|
|
214
|
+
}),
|
|
215
|
+
new Promise((_, reject) => {
|
|
216
|
+
timeout = setTimeout(
|
|
217
|
+
() => reject(new Error("Declaration did not settle")),
|
|
218
|
+
500,
|
|
219
|
+
);
|
|
220
|
+
}),
|
|
221
|
+
]),
|
|
222
|
+
);
|
|
223
|
+
expect(error.message).to.contain("cannot be its own parent");
|
|
224
|
+
expect(
|
|
225
|
+
(
|
|
226
|
+
await EnsureMediaFolder({
|
|
227
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
228
|
+
key,
|
|
229
|
+
name: "Not self",
|
|
230
|
+
})
|
|
231
|
+
).status,
|
|
232
|
+
).to.equal("created");
|
|
233
|
+
} finally {
|
|
234
|
+
clearTimeout(timeout);
|
|
235
|
+
}
|
|
236
|
+
});
|
|
237
|
+
|
|
238
|
+
it("rejects moving a declared ancestor under its descendant", async () => {
|
|
239
|
+
const root = {
|
|
240
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
241
|
+
key: "declared.cycle-root",
|
|
242
|
+
name: "Cycle root",
|
|
243
|
+
};
|
|
244
|
+
const parent = await EnsureMediaFolder(root);
|
|
245
|
+
const child = await EnsureMediaFolder({
|
|
246
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
247
|
+
key: "declared.cycle-child",
|
|
248
|
+
name: "Cycle child",
|
|
249
|
+
parent: root.key,
|
|
250
|
+
});
|
|
251
|
+
const error = await rejectionOf(
|
|
252
|
+
EnsureMediaFolder({ ...root, parent: "declared.cycle-child" }),
|
|
253
|
+
);
|
|
254
|
+
expect(error.message).to.contain("inside itself");
|
|
255
|
+
expect((await folders().get(parent.id as string))?.path).to.deep.equal(
|
|
256
|
+
[],
|
|
257
|
+
);
|
|
258
|
+
expect((await folders().get(child.id as string))?.path).to.deep.equal([
|
|
259
|
+
parent.id,
|
|
260
|
+
]);
|
|
261
|
+
const destination = await EnsureMediaFolder({
|
|
262
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
263
|
+
key: "declared.move-target",
|
|
264
|
+
name: "Move target",
|
|
265
|
+
});
|
|
266
|
+
expect(
|
|
267
|
+
(await EnsureMediaFolder({ ...root, parent: "declared.move-target" }))
|
|
268
|
+
.status,
|
|
269
|
+
).to.equal("updated");
|
|
270
|
+
expect((await folders().get(child.id as string))?.path).to.deep.equal([
|
|
271
|
+
destination.id,
|
|
272
|
+
parent.id,
|
|
273
|
+
]);
|
|
274
|
+
expect((await EnsureMediaFolder(root)).status).to.equal("updated");
|
|
275
|
+
expect(
|
|
276
|
+
(await folders().get(parent.id as string))?.parentId ?? undefined,
|
|
277
|
+
).to.equal(undefined);
|
|
278
|
+
expect((await folders().get(child.id as string))?.path).to.deep.equal([
|
|
279
|
+
parent.id,
|
|
280
|
+
]);
|
|
281
|
+
});
|
|
282
|
+
|
|
283
|
+
it("preserves a member rename racing a folder refresh", async () => {
|
|
284
|
+
const declaration = {
|
|
285
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
286
|
+
key: "declared.folder-race",
|
|
287
|
+
name: "Folder before race",
|
|
288
|
+
};
|
|
289
|
+
const first = await EnsureMediaFolder(declaration);
|
|
290
|
+
// oxlint-disable-next-line typescript/unbound-method -- Rebound with call(this) below and restored in finally.
|
|
291
|
+
const original = MediaFolderModel.prototype.get;
|
|
292
|
+
let renamed = false;
|
|
293
|
+
MediaFolderModel.prototype.get = async function (id) {
|
|
294
|
+
const snapshot = await original.call(this, id);
|
|
295
|
+
if (id === first.id && !renamed) {
|
|
296
|
+
renamed = true;
|
|
297
|
+
await client.post(`/api/media/folders/${id}/rename`, {
|
|
298
|
+
name: "Member folder name",
|
|
299
|
+
});
|
|
300
|
+
}
|
|
301
|
+
return snapshot;
|
|
302
|
+
};
|
|
303
|
+
try {
|
|
304
|
+
const result = await EnsureMediaFolder({
|
|
305
|
+
...declaration,
|
|
306
|
+
name: "Code folder name",
|
|
307
|
+
visibility: "public",
|
|
308
|
+
});
|
|
309
|
+
expect(result).to.deep.equal({ status: "preserved", id: first.id });
|
|
310
|
+
const folder = await folders().get(first.id as string);
|
|
311
|
+
expect(folder?.name).to.equal("Member folder name");
|
|
312
|
+
expect(folder?.visibility).to.equal("private");
|
|
313
|
+
expect((await EnsureMediaFolder(declaration)).status).to.equal(
|
|
314
|
+
"preserved",
|
|
315
|
+
);
|
|
316
|
+
} finally {
|
|
317
|
+
MediaFolderModel.prototype.get = original;
|
|
318
|
+
}
|
|
319
|
+
});
|
|
320
|
+
|
|
321
|
+
it("creates a folder once, however often it is declared", async () => {
|
|
322
|
+
const declaration = {
|
|
323
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
324
|
+
key: ROOT_KEY,
|
|
325
|
+
name: "Declared procedures",
|
|
326
|
+
};
|
|
327
|
+
const first = await EnsureMediaFolder(declaration);
|
|
328
|
+
const second = await EnsureMediaFolder(declaration);
|
|
329
|
+
expect(first.status).to.equal("created");
|
|
330
|
+
expect(second).to.deep.equal({ status: "unchanged", id: first.id });
|
|
331
|
+
const folder = await folders().get(first.id as string);
|
|
332
|
+
expect(folder?.name).to.equal("Declared procedures");
|
|
333
|
+
expect(folder?.parentId ?? undefined).to.equal(undefined);
|
|
334
|
+
expect(folder?.visibility).to.equal("private");
|
|
335
|
+
const events = await GetModel(MediaEventModel, DEFAULT_TENANT_ID).getBy(
|
|
336
|
+
"kind",
|
|
337
|
+
"folder.create",
|
|
338
|
+
);
|
|
339
|
+
const created = events.filter((event) =>
|
|
340
|
+
event.json_details?.includes(first.id as string),
|
|
341
|
+
);
|
|
342
|
+
expect(created).to.have.length(1);
|
|
343
|
+
expect(created[0]?.actorName).to.equal("System");
|
|
344
|
+
});
|
|
345
|
+
|
|
346
|
+
it("nests a folder under a declared parent with its visibility and ACL", async () => {
|
|
347
|
+
const parent = await EnsureMediaFolder({
|
|
348
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
349
|
+
key: ROOT_KEY,
|
|
350
|
+
name: "Declared procedures",
|
|
351
|
+
});
|
|
352
|
+
const child = await EnsureMediaFolder({
|
|
353
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
354
|
+
key: CHILD_KEY,
|
|
355
|
+
name: "Safety",
|
|
356
|
+
parent: ROOT_KEY,
|
|
357
|
+
visibility: "public",
|
|
358
|
+
acl: ACL,
|
|
359
|
+
});
|
|
360
|
+
expect(child.status).to.equal("created");
|
|
361
|
+
const folder = await folders().get(child.id as string);
|
|
362
|
+
expect(folder?.parentId).to.equal(parent.id);
|
|
363
|
+
expect(folder?.path).to.deep.equal([parent.id]);
|
|
364
|
+
expect(folder?.visibility).to.equal("public");
|
|
365
|
+
expect(await readFolderAcl(child.id as string)).to.deep.equal(ACL);
|
|
366
|
+
const tree = await client.get("/api/media/tree");
|
|
367
|
+
expect(tree.status).to.equal(HTTP_OK);
|
|
368
|
+
expect(
|
|
369
|
+
tree.data.folders.filter(
|
|
370
|
+
(entry: { name: string }) => entry.name === "Safety",
|
|
371
|
+
),
|
|
372
|
+
).to.have.length(1);
|
|
373
|
+
});
|
|
374
|
+
|
|
375
|
+
it("refreshes a folder still as declared", async () => {
|
|
376
|
+
const result = await EnsureMediaFolder({
|
|
377
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
378
|
+
key: CHILD_KEY,
|
|
379
|
+
name: "Safety rules",
|
|
380
|
+
parent: ROOT_KEY,
|
|
381
|
+
});
|
|
382
|
+
expect(result.status).to.equal("updated");
|
|
383
|
+
const folder = await folders().get(result.id as string);
|
|
384
|
+
expect(folder?.name).to.equal("Safety rules");
|
|
385
|
+
expect(folder?.visibility).to.equal("private");
|
|
386
|
+
expect(await readFolderAcl(result.id as string)).to.equal(undefined);
|
|
387
|
+
});
|
|
388
|
+
|
|
389
|
+
it("leaves a folder a member renamed as they made it", async () => {
|
|
390
|
+
const declared = await EnsureMediaFolder({
|
|
391
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
392
|
+
key: "declared.renamed",
|
|
393
|
+
name: "Declared templates",
|
|
394
|
+
});
|
|
395
|
+
const rename = await client.post(
|
|
396
|
+
`/api/media/folders/${declared.id}/rename`,
|
|
397
|
+
{ name: "Our templates" },
|
|
398
|
+
);
|
|
399
|
+
expect(rename.status).to.equal(HTTP_OK);
|
|
400
|
+
const result = await EnsureMediaFolder({
|
|
401
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
402
|
+
key: "declared.renamed",
|
|
403
|
+
name: "Declared templates v2",
|
|
404
|
+
});
|
|
405
|
+
expect(result).to.deep.equal({ status: "preserved", id: declared.id });
|
|
406
|
+
const folder = await folders().get(declared.id as string);
|
|
407
|
+
expect(folder?.name).to.equal("Our templates");
|
|
408
|
+
});
|
|
409
|
+
|
|
410
|
+
it("does not bring back a folder a member deleted", async () => {
|
|
411
|
+
const declared = await EnsureMediaFolder({
|
|
412
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
413
|
+
key: "declared.deleted",
|
|
414
|
+
name: "Declared archive",
|
|
415
|
+
});
|
|
416
|
+
const removal = await client.delete(`/api/media/folders/${declared.id}`);
|
|
417
|
+
expect(removal.status).to.equal(HTTP_OK);
|
|
418
|
+
const result = await EnsureMediaFolder({
|
|
419
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
420
|
+
key: "declared.deleted",
|
|
421
|
+
name: "Declared archive",
|
|
422
|
+
});
|
|
423
|
+
expect(result).to.deep.equal({ status: "deleted" });
|
|
424
|
+
const all = await folders().getAll();
|
|
425
|
+
expect(all.some((folder) => folder.name === "Declared archive")).to.equal(
|
|
426
|
+
false,
|
|
427
|
+
);
|
|
428
|
+
});
|
|
429
|
+
|
|
430
|
+
it("refuses an invalid name, an unknown parent and a taken name", async () => {
|
|
431
|
+
const badName = await rejectionOf(
|
|
432
|
+
EnsureMediaFolder({
|
|
433
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
434
|
+
key: "declared.bad",
|
|
435
|
+
name: "a/b",
|
|
436
|
+
}),
|
|
437
|
+
);
|
|
438
|
+
expect(badName.message).to.contain("declared.bad").and.contain("name");
|
|
439
|
+
const orphan = await rejectionOf(
|
|
440
|
+
EnsureMediaFolder({
|
|
441
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
442
|
+
key: "declared.orphan",
|
|
443
|
+
name: "Orphan",
|
|
444
|
+
parent: "declared.missing",
|
|
445
|
+
}),
|
|
446
|
+
);
|
|
447
|
+
expect(orphan.message).to.contain("declared.missing");
|
|
448
|
+
const taken = await rejectionOf(
|
|
449
|
+
EnsureMediaFolder({
|
|
450
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
451
|
+
key: "declared.twin",
|
|
452
|
+
name: "declared PROCEDURES",
|
|
453
|
+
}),
|
|
454
|
+
);
|
|
455
|
+
expect(taken.message).to.contain("already exists");
|
|
456
|
+
});
|
|
457
|
+
});
|
|
458
|
+
|
|
459
|
+
describe("files", () => {
|
|
460
|
+
for (const replaceBytes of [false, true]) {
|
|
461
|
+
it(`preserves a member rename racing an asset ${replaceBytes ? "content" : "metadata"} refresh`, async () => {
|
|
462
|
+
const declaration = {
|
|
463
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
464
|
+
key: `declared.asset-race.${replaceBytes}`,
|
|
465
|
+
folder: { key: ROOT_KEY },
|
|
466
|
+
name: `race-${replaceBytes}.txt`,
|
|
467
|
+
mimetype: "text/plain",
|
|
468
|
+
source: { bytes: Buffer.from("Original content") },
|
|
469
|
+
};
|
|
470
|
+
const first = await ImportMediaAsset(declaration);
|
|
471
|
+
const before = await assets().get(first.id as string);
|
|
472
|
+
// oxlint-disable-next-line typescript/unbound-method -- Rebound with call(this) below and restored in finally.
|
|
473
|
+
const original = MediaAssetModel.prototype.get;
|
|
474
|
+
let reads = 0;
|
|
475
|
+
MediaAssetModel.prototype.get = async function (id) {
|
|
476
|
+
const snapshot = await original.call(this, id);
|
|
477
|
+
// Race the last snapshot used to publish, not just the initial verdict.
|
|
478
|
+
if (id === first.id && ++reads === 2) {
|
|
479
|
+
await client.post(`/api/media/assets/${id}/update`, {
|
|
480
|
+
name: `member-${replaceBytes}.txt`,
|
|
481
|
+
});
|
|
482
|
+
}
|
|
483
|
+
return snapshot;
|
|
484
|
+
};
|
|
485
|
+
try {
|
|
486
|
+
const result = await ImportMediaAsset({
|
|
487
|
+
...declaration,
|
|
488
|
+
name: `code-${replaceBytes}.txt`,
|
|
489
|
+
source: replaceBytes
|
|
490
|
+
? { bytes: Buffer.from("Replacement content") }
|
|
491
|
+
: declaration.source,
|
|
492
|
+
});
|
|
493
|
+
expect(result).to.deep.equal({ status: "preserved", id: first.id });
|
|
494
|
+
const after = await assets().get(first.id as string);
|
|
495
|
+
expect(after?.name).to.equal(`member-${replaceBytes}.txt`);
|
|
496
|
+
expect(after?.storageKey).to.equal(before?.storageKey);
|
|
497
|
+
expect((await ImportMediaAsset(declaration)).status).to.equal(
|
|
498
|
+
"preserved",
|
|
499
|
+
);
|
|
500
|
+
} finally {
|
|
501
|
+
MediaAssetModel.prototype.get = original;
|
|
502
|
+
}
|
|
503
|
+
});
|
|
504
|
+
}
|
|
505
|
+
|
|
506
|
+
it("imports bytes once, with their dimensions and an upload event", async () => {
|
|
507
|
+
const declaration = {
|
|
508
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
509
|
+
key: "declared.logo",
|
|
510
|
+
folder: { key: ROOT_KEY },
|
|
511
|
+
name: "logo.png",
|
|
512
|
+
mimetype: PNG_MIMETYPE,
|
|
513
|
+
alt: "Helio logo",
|
|
514
|
+
source: { bytes: ONE_PIXEL_PNG },
|
|
515
|
+
};
|
|
516
|
+
const first = await ImportMediaAsset(declaration);
|
|
517
|
+
const second = await ImportMediaAsset(declaration);
|
|
518
|
+
expect(first.status).to.equal("created");
|
|
519
|
+
expect(second).to.deep.equal({ status: "unchanged", id: first.id });
|
|
520
|
+
const asset = await assets().get(first.id as string);
|
|
521
|
+
expect(asset?.name).to.equal("logo.png");
|
|
522
|
+
expect(asset?.alt).to.equal("Helio logo");
|
|
523
|
+
expect(asset?.width).to.equal(1);
|
|
524
|
+
expect(asset?.height).to.equal(1);
|
|
525
|
+
expect(asset?.size).to.equal(ONE_PIXEL_PNG.byteLength);
|
|
526
|
+
const events = await GetModel(
|
|
527
|
+
MediaEventModel,
|
|
528
|
+
DEFAULT_TENANT_ID,
|
|
529
|
+
).listByAsset(first.id as string);
|
|
530
|
+
expect(events.map((event) => event.kind)).to.deep.equal(["asset.upload"]);
|
|
531
|
+
const readUrl = await client.get(
|
|
532
|
+
`/api/media/assets/${first.id}/read-url`,
|
|
533
|
+
);
|
|
534
|
+
expect(readUrl.status).to.equal(HTTP_OK);
|
|
535
|
+
const stored = await fetch(readUrl.data.url);
|
|
536
|
+
expect(Buffer.from(await stored.arrayBuffer())).to.deep.equal(
|
|
537
|
+
ONE_PIXEL_PNG,
|
|
538
|
+
);
|
|
539
|
+
});
|
|
540
|
+
|
|
541
|
+
it("imports a file from a local path", async () => {
|
|
542
|
+
const filePath = join(tempDir, "checklist.txt");
|
|
543
|
+
await writeFile(filePath, "1. Switch the inverter off");
|
|
544
|
+
const result = await ImportMediaAsset({
|
|
545
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
546
|
+
key: "declared.checklist",
|
|
547
|
+
folder: { key: CHILD_KEY },
|
|
548
|
+
name: "checklist.txt",
|
|
549
|
+
mimetype: "text/plain",
|
|
550
|
+
source: { filePath },
|
|
551
|
+
});
|
|
552
|
+
expect(result.status).to.equal("created");
|
|
553
|
+
const asset = await assets().get(result.id as string);
|
|
554
|
+
expect(asset?.mimetype).to.equal("text/plain");
|
|
555
|
+
expect(asset?.width ?? undefined).to.equal(undefined);
|
|
556
|
+
});
|
|
557
|
+
|
|
558
|
+
it("imports into the folder bound to an asset field, with its types", async () => {
|
|
559
|
+
const result = await ImportMediaAsset({
|
|
560
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
561
|
+
key: "declared.cover",
|
|
562
|
+
folder: { binding: BINDING_ID },
|
|
563
|
+
name: "cover.png",
|
|
564
|
+
mimetype: PNG_MIMETYPE,
|
|
565
|
+
source: { bytes: ONE_PIXEL_PNG },
|
|
566
|
+
});
|
|
567
|
+
expect(result.status).to.equal("created");
|
|
568
|
+
const asset = await assets().get(result.id as string);
|
|
569
|
+
const bound = await folders().getByBinding(BINDING_ID);
|
|
570
|
+
expect(asset?.folderId).to.equal(bound?._id);
|
|
571
|
+
const refused = await rejectionOf(
|
|
572
|
+
ImportMediaAsset({
|
|
573
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
574
|
+
key: "declared.cover-notes",
|
|
575
|
+
folder: { binding: BINDING_ID },
|
|
576
|
+
name: "notes.txt",
|
|
577
|
+
mimetype: "text/plain",
|
|
578
|
+
source: { bytes: Buffer.from("notes") },
|
|
579
|
+
}),
|
|
580
|
+
);
|
|
581
|
+
expect(refused.message).to.contain("only accepts image/*");
|
|
582
|
+
});
|
|
583
|
+
|
|
584
|
+
it("refreshes the content of a file still as declared", async () => {
|
|
585
|
+
const declaration = {
|
|
586
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
587
|
+
key: "declared.banner",
|
|
588
|
+
folder: { key: ROOT_KEY },
|
|
589
|
+
name: "banner.png",
|
|
590
|
+
mimetype: PNG_MIMETYPE,
|
|
591
|
+
};
|
|
592
|
+
const first = await ImportMediaAsset({
|
|
593
|
+
...declaration,
|
|
594
|
+
source: { bytes: await squarePng(2) },
|
|
595
|
+
});
|
|
596
|
+
const before = await assets().get(first.id as string);
|
|
597
|
+
const second = await ImportMediaAsset({
|
|
598
|
+
...declaration,
|
|
599
|
+
source: { bytes: await squarePng(3) },
|
|
600
|
+
});
|
|
601
|
+
expect(second).to.deep.equal({ status: "updated", id: first.id });
|
|
602
|
+
const after = await assets().get(first.id as string);
|
|
603
|
+
expect(after?.width).to.equal(3);
|
|
604
|
+
expect(after?.storageKey).to.not.equal(before?.storageKey);
|
|
605
|
+
const third = await ImportMediaAsset({
|
|
606
|
+
...declaration,
|
|
607
|
+
source: { bytes: await squarePng(3) },
|
|
608
|
+
});
|
|
609
|
+
expect(third.status).to.equal("unchanged");
|
|
610
|
+
});
|
|
611
|
+
|
|
612
|
+
it("does not read the source while the caller's version is unchanged", async () => {
|
|
613
|
+
let loads = 0;
|
|
614
|
+
const load = (text: string) => () => {
|
|
615
|
+
loads++;
|
|
616
|
+
return Buffer.from(text);
|
|
617
|
+
};
|
|
618
|
+
const declaration = {
|
|
619
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
620
|
+
key: "declared.generated",
|
|
621
|
+
folder: { key: ROOT_KEY },
|
|
622
|
+
name: "generated.txt",
|
|
623
|
+
mimetype: "text/plain",
|
|
624
|
+
};
|
|
625
|
+
const first = await ImportMediaAsset({
|
|
626
|
+
...declaration,
|
|
627
|
+
version: "v1",
|
|
628
|
+
source: { load: load("Generated v1") },
|
|
629
|
+
});
|
|
630
|
+
expect(first.status).to.equal("created");
|
|
631
|
+
expect(loads).to.equal(1);
|
|
632
|
+
// Same version: neither the loader nor a file path that does not exist is read.
|
|
633
|
+
expect(
|
|
634
|
+
await ImportMediaAsset({
|
|
635
|
+
...declaration,
|
|
636
|
+
version: "v1",
|
|
637
|
+
source: { load: load("never read") },
|
|
638
|
+
}),
|
|
639
|
+
).to.deep.equal({ status: "unchanged", id: first.id });
|
|
640
|
+
expect(
|
|
641
|
+
(
|
|
642
|
+
await ImportMediaAsset({
|
|
643
|
+
...declaration,
|
|
644
|
+
version: "v1",
|
|
645
|
+
source: { filePath: join(tempDir, "never-written.txt") },
|
|
646
|
+
})
|
|
647
|
+
).status,
|
|
648
|
+
).to.equal("unchanged");
|
|
649
|
+
expect(loads).to.equal(1);
|
|
650
|
+
// New metadata under the same version refreshes without reading the bytes.
|
|
651
|
+
const renamed = await ImportMediaAsset({
|
|
652
|
+
...declaration,
|
|
653
|
+
version: "v1",
|
|
654
|
+
name: "generated-renamed.txt",
|
|
655
|
+
source: { load: load("never read") },
|
|
656
|
+
});
|
|
657
|
+
expect(renamed).to.deep.equal({ status: "updated", id: first.id });
|
|
658
|
+
expect(loads).to.equal(1);
|
|
659
|
+
const updated = await ImportMediaAsset({
|
|
660
|
+
...declaration,
|
|
661
|
+
version: "v2",
|
|
662
|
+
name: "generated-renamed.txt",
|
|
663
|
+
source: { load: load("Generated v2") },
|
|
664
|
+
});
|
|
665
|
+
expect(updated).to.deep.equal({ status: "updated", id: first.id });
|
|
666
|
+
expect(loads).to.equal(2);
|
|
667
|
+
const asset = await assets().get(first.id as string);
|
|
668
|
+
expect(asset?.size).to.equal("Generated v2".length);
|
|
669
|
+
});
|
|
670
|
+
|
|
671
|
+
it("reads a new version once, and not again when its bytes did not change", async () => {
|
|
672
|
+
let loads = 0;
|
|
673
|
+
const declaration = {
|
|
674
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
675
|
+
key: "declared.rebuilt",
|
|
676
|
+
folder: { key: ROOT_KEY },
|
|
677
|
+
name: "rebuilt.txt",
|
|
678
|
+
mimetype: "text/plain",
|
|
679
|
+
source: {
|
|
680
|
+
load: async () => {
|
|
681
|
+
loads++;
|
|
682
|
+
return Buffer.from("Same bytes");
|
|
683
|
+
},
|
|
684
|
+
},
|
|
685
|
+
};
|
|
686
|
+
const first = await ImportMediaAsset({ ...declaration, version: "a" });
|
|
687
|
+
const rebuilt = await ImportMediaAsset({ ...declaration, version: "b" });
|
|
688
|
+
expect(rebuilt).to.deep.equal({ status: "unchanged", id: first.id });
|
|
689
|
+
expect(loads).to.equal(2);
|
|
690
|
+
expect(
|
|
691
|
+
(await ImportMediaAsset({ ...declaration, version: "b" })).status,
|
|
692
|
+
).to.equal("unchanged");
|
|
693
|
+
expect(loads).to.equal(2);
|
|
694
|
+
});
|
|
695
|
+
|
|
696
|
+
it("does not read the source of a file a member changed or deleted", async () => {
|
|
697
|
+
let loads = 0;
|
|
698
|
+
const declaration = {
|
|
699
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
700
|
+
key: "declared.untouchable",
|
|
701
|
+
folder: { key: ROOT_KEY },
|
|
702
|
+
name: "untouchable.txt",
|
|
703
|
+
mimetype: "text/plain",
|
|
704
|
+
source: {
|
|
705
|
+
load: () => {
|
|
706
|
+
loads++;
|
|
707
|
+
return Buffer.from(`Untouchable ${loads}`);
|
|
708
|
+
},
|
|
709
|
+
},
|
|
710
|
+
};
|
|
711
|
+
const first = await ImportMediaAsset(declaration);
|
|
712
|
+
await client.post(`/api/media/assets/${first.id}/update`, {
|
|
713
|
+
name: "member-owned.txt",
|
|
714
|
+
});
|
|
715
|
+
expect((await ImportMediaAsset(declaration)).status).to.equal(
|
|
716
|
+
"preserved",
|
|
717
|
+
);
|
|
718
|
+
await client.delete(`/api/media/assets/${first.id}`);
|
|
719
|
+
expect((await ImportMediaAsset(declaration)).status).to.equal("deleted");
|
|
720
|
+
expect(loads).to.equal(1);
|
|
721
|
+
});
|
|
722
|
+
|
|
723
|
+
it("names the key when a lazy source fails or returns no bytes", async () => {
|
|
724
|
+
const declaration = {
|
|
725
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
726
|
+
folder: { key: ROOT_KEY },
|
|
727
|
+
name: "lazy.txt",
|
|
728
|
+
mimetype: "text/plain",
|
|
729
|
+
};
|
|
730
|
+
const thrown = await rejectionOf(
|
|
731
|
+
ImportMediaAsset({
|
|
732
|
+
...declaration,
|
|
733
|
+
key: "declared.lazy-throws",
|
|
734
|
+
source: {
|
|
735
|
+
load: () => {
|
|
736
|
+
throw new Error("renderer crashed");
|
|
737
|
+
},
|
|
738
|
+
},
|
|
739
|
+
}),
|
|
740
|
+
);
|
|
741
|
+
expect(thrown.message)
|
|
742
|
+
.to.contain("declared.lazy-throws")
|
|
743
|
+
.and.contain("renderer crashed");
|
|
744
|
+
const wrong = await rejectionOf(
|
|
745
|
+
ImportMediaAsset({
|
|
746
|
+
...declaration,
|
|
747
|
+
key: "declared.lazy-wrong",
|
|
748
|
+
source: {
|
|
749
|
+
// @ts-expect-error A JavaScript caller can return something else.
|
|
750
|
+
load: () => "text",
|
|
751
|
+
},
|
|
752
|
+
}),
|
|
753
|
+
);
|
|
754
|
+
expect(wrong.message).to.contain("must return a Uint8Array");
|
|
755
|
+
});
|
|
756
|
+
|
|
757
|
+
it("leaves a file a member renamed as they made it", async () => {
|
|
758
|
+
const declaration = {
|
|
759
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
760
|
+
key: "declared.manual",
|
|
761
|
+
folder: { key: ROOT_KEY },
|
|
762
|
+
name: "manual.txt",
|
|
763
|
+
mimetype: "text/plain",
|
|
764
|
+
source: { bytes: Buffer.from("Manual v1") },
|
|
765
|
+
};
|
|
766
|
+
const first = await ImportMediaAsset(declaration);
|
|
767
|
+
const rename = await client.post(`/api/media/assets/${first.id}/update`, {
|
|
768
|
+
name: "our-manual.txt",
|
|
769
|
+
});
|
|
770
|
+
expect(rename.status).to.equal(HTTP_OK);
|
|
771
|
+
const result = await ImportMediaAsset({
|
|
772
|
+
...declaration,
|
|
773
|
+
source: { bytes: Buffer.from("Manual v2") },
|
|
774
|
+
});
|
|
775
|
+
expect(result).to.deep.equal({ status: "preserved", id: first.id });
|
|
776
|
+
const asset = await assets().get(first.id as string);
|
|
777
|
+
expect(asset?.name).to.equal("our-manual.txt");
|
|
778
|
+
expect(asset?.size).to.equal("Manual v1".length);
|
|
779
|
+
});
|
|
780
|
+
|
|
781
|
+
it("does not bring back a file a member deleted", async () => {
|
|
782
|
+
const declaration = {
|
|
783
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
784
|
+
key: "declared.flyer",
|
|
785
|
+
folder: { key: ROOT_KEY },
|
|
786
|
+
name: "flyer.txt",
|
|
787
|
+
mimetype: "text/plain",
|
|
788
|
+
source: { bytes: Buffer.from("Flyer") },
|
|
789
|
+
};
|
|
790
|
+
const first = await ImportMediaAsset(declaration);
|
|
791
|
+
const removal = await client.delete(`/api/media/assets/${first.id}`);
|
|
792
|
+
expect(removal.status).to.equal(HTTP_OK);
|
|
793
|
+
const result = await ImportMediaAsset(declaration);
|
|
794
|
+
expect(result).to.deep.equal({ status: "deleted" });
|
|
795
|
+
});
|
|
796
|
+
|
|
797
|
+
it("refuses an unknown folder, a refused type and an unreadable image", async () => {
|
|
798
|
+
const unknown = await rejectionOf(
|
|
799
|
+
ImportMediaAsset({
|
|
800
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
801
|
+
key: "declared.lost",
|
|
802
|
+
folder: { key: "declared.nowhere" },
|
|
803
|
+
name: "lost.txt",
|
|
804
|
+
mimetype: "text/plain",
|
|
805
|
+
source: { bytes: Buffer.from("lost") },
|
|
806
|
+
}),
|
|
807
|
+
);
|
|
808
|
+
expect(unknown.message).to.contain("declared.nowhere");
|
|
809
|
+
const html = await rejectionOf(
|
|
810
|
+
ImportMediaAsset({
|
|
811
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
812
|
+
key: "declared.page",
|
|
813
|
+
folder: { key: ROOT_KEY },
|
|
814
|
+
name: "page.html",
|
|
815
|
+
mimetype: "text/html",
|
|
816
|
+
source: { bytes: Buffer.from("<p>hi</p>") },
|
|
817
|
+
}),
|
|
818
|
+
);
|
|
819
|
+
expect(html.message).to.contain("can't be added");
|
|
820
|
+
const broken = await rejectionOf(
|
|
821
|
+
ImportMediaAsset({
|
|
822
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
823
|
+
key: "declared.broken",
|
|
824
|
+
folder: { key: ROOT_KEY },
|
|
825
|
+
name: "broken.png",
|
|
826
|
+
mimetype: PNG_MIMETYPE,
|
|
827
|
+
source: { bytes: Buffer.from("not a png") },
|
|
828
|
+
}),
|
|
829
|
+
);
|
|
830
|
+
expect(broken.message).to.contain("not a readable image");
|
|
831
|
+
const missing = await rejectionOf(
|
|
832
|
+
ImportMediaAsset({
|
|
833
|
+
tenantId: DEFAULT_TENANT_ID,
|
|
834
|
+
key: "declared.missing-file",
|
|
835
|
+
folder: { key: ROOT_KEY },
|
|
836
|
+
name: "missing.txt",
|
|
837
|
+
mimetype: "text/plain",
|
|
838
|
+
source: { filePath: join(tempDir, "missing.txt") },
|
|
839
|
+
}),
|
|
840
|
+
);
|
|
841
|
+
expect(missing.message).to.contain("cannot read");
|
|
842
|
+
});
|
|
843
|
+
});
|
|
844
|
+
});
|