Hello Typescript!

hydro/model/file.ts

@@ -0,0 +1,104 @@
+import { ObjectID } from 'mongodb';
+import * as fs from 'fs';
+import { ForbiddenError, NotFoundError } from '../error';
+import * as db from '../service/db';
+import gridfs from '../service/gridfs';
+import hash from '../lib/hash.hydro';
+
+const coll = db.collection('file');
+const collFile = db.collection('fs.files');
+const collChunk = db.collection('fs.chunks');
+
+function _timestamp() {
+    return Math.floor(Number(new Date()) / 1000000);
+}
+
+export async function add(streamOrPath: fs.ReadStream | string, filename: string, meta = {}) {
+    let stream: fs.ReadStream;
+    if (typeof streamOrPath === 'string') stream = fs.createReadStream(streamOrPath);
+    else stream = streamOrPath;
+    const w = gridfs.openUploadStream(filename);
+    await coll.insertOne({ ...meta, _id: w.id, secret: String.random(32) });
+    await new Promise((resolve, reject) => {
+        w.on('error', reject);
+        w.on('finish', resolve);
+        stream.pipe(w);
+    });
+    const c = await gridfs.find({ _id: w.id }).toArray();
+    await coll.updateOne({ _id: w.id }, { $set: { md5: c[0].md5, size: c[0].size } });
+    return w.id;
+}
+
+export function del(_id: ObjectID) {
+    return Promise.all([
+        coll.deleteOne({ _id }),
+        collFile.deleteOne({ _id }),
+        collChunk.deleteMany({ files_id: _id }),
+    ]);
+}
+
+export async function inc(_id: ObjectID) {
+    const doc = await coll.findOneAndUpdate(
+        { _id },
+        { $inc: { count: 1 } },
+        { returnOriginal: false },
+    );
+    return (doc.value || {}).count;
+}
+
+export async function dec(_id: ObjectID) {
+    const file = await coll.findOneAndUpdate(
+        { _id },
+        { $inc: { count: -1 } },
+        { returnOriginal: false },
+    );
+    if (!file.value.count) await del(_id);
+    return file.value.count;
+}
+
+export async function getWithSecret(_id: ObjectID, secret: string) {
+    const file = await coll.findOne({ _id });
+    if (!file) throw new NotFoundError(_id);
+    const timestamp = _timestamp();
+    if (!(hash(file.secret, timestamp.toString()) === secret)) {
+        if (!(hash(file.secret, (timestamp - 1).toString()) === secret)) {
+            throw new ForbiddenError();
+        }
+    }
+    return gridfs.openDownloadStream(_id);
+}
+
+export async function get(_id: ObjectID) {
+    const file = await coll.findOne({ _id });
+    if (!file) throw new NotFoundError(_id);
+    return gridfs.openDownloadStream(_id);
+}
+
+export function getMeta(_id: ObjectID) {
+    return coll.findOne({ _id });
+}
+
+export async function getMetaDict(ufids: ObjectID[]) {
+    const r = {};
+    ufids = Array.from(new Set(ufids));
+    const ufdocs = await coll.find({ _id: { $in: ufids } }).toArray();
+    for (const ufdoc of ufdocs) {
+        r[ufdoc._id.toHexString()] = ufdoc;
+    }
+    return r;
+}
+
+export function getMulti(query: any) {
+    return coll.find(query);
+}
+
+export async function url(_id: ObjectID, name: string | undefined) {
+    const file = await coll.findOne({ _id });
+    const secret = hash(file.secret, _timestamp().toString());
+    if (name) return `/fs/${_id}/${Buffer.from(name).toString('base64')}/${secret}`;
+    return `/fs/${_id}/${secret}`;
+}
+
+global.Hydro.model.file = {
+    add, get, del, inc, dec, getMeta, getWithSecret, getMulti, getMetaDict, url,
+};