dfs-adapter 0.0.1

package/README.md

@@ -0,0 +1 @@
+###

package/lib/declare.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { VWebApplicationContext } from "vweb-core";
+export declare interface OssConfig {
+    accessKeyId: string;
+    accessKeySecret: string;
+    stsToken?: string | undefined;
+    bucket?: string | undefined;
+    endpoint?: string | undefined;
+    region?: string | undefined;
+    internal?: boolean | undefined;
+    secure?: boolean | undefined;
+    timeout?: string | number | undefined;
+    cname?: boolean | undefined;
+    [key: string]: any;
+    access: string;
+}
+export declare interface MinioConfig {
+    endPoint: string;
+    port: number;
+    accessKey: string;
+    secretKey: string;
+    bucketName: string;
+    [key: string]: any;
+    access: string;
+}
+export declare interface HttpConfig {
+    url: string;
+    headers: {
+        Authorization: string;
+        [key: string]: any;
+    };
+    body: {
+        [key: string]: any;
+    };
+    access: string;
+}
+export declare interface NativeConfig {
+    storage: string;
+    access: string;
+}
+export declare interface FastdfsConfig {
+    domain: string;
+    group: string;
+    token: string;
+    access: string;
+}
+export declare type ConfigOptionsMap = {
+    oss: OssConfig;
+    minio: MinioConfig;
+    http: HttpConfig;
+    native: NativeConfig;
+    fastdfs: FastdfsConfig;
+};
+export declare type ConfigOptionsKey = keyof ConfigOptionsMap;
+type ConfigOptionsOptions<T> = T extends ConfigOptionsKey ? {
+    type: T;
+} & ConfigOptionsMap[T] : never;
+export type DfsConfig = ConfigOptionsOptions<ConfigOptionsKey>;
+export declare const defineDfsConfig: (config: DfsConfig) => DfsConfig;
+export declare class Dfs<T extends ConfigOptionsKey> {
+    protected readonly context: VWebApplicationContext;
+    protected readonly options: ConfigOptionsOptions<T>;
+    protected readonly logger: Logger;
+    private readonly timeMap;
+    constructor(options: ConfigOptionsOptions<T>, context: VWebApplicationContext);
+    protected getTmpFile(file: string): string;
+    protected timeBegin(label: string): void;
+    protected timeEnd(label: string): void;
+    protected stream2buffer(stream: NodeJS.ReadableStream): Promise<Buffer>;
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}
+export {};

package/lib/declare.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dfs = exports.defineDfsConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const defineDfsConfig = (config) => config;
+exports.defineDfsConfig = defineDfsConfig;
+class Dfs {
+    constructor(options, context) {
+        this.options = options;
+        this.context = context;
+        this.logger = context.log4j.getLogger('Dfs');
+        this.timeMap = new Map();
+    }
+    getTmpFile(file) {
+        let base = path_1.default.resolve('.');
+        let tmpDir = base + '/tmp';
+        if (!fs_1.default.existsSync(tmpDir)) {
+            fs_1.default.mkdirSync(tmpDir);
+        }
+        return tmpDir + `/${file}`;
+    }
+    timeBegin(label) {
+        this.timeMap.set(label, Date.now());
+    }
+    timeEnd(label) {
+        const costTime = Date.now() - this.timeMap.get(label);
+        this.logger.info(`${label} cost [${costTime}ms]`);
+    }
+    stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const buffers = [];
+            stream.on('data', chunk => {
+                buffers.push(chunk);
+            });
+            stream.on('end', () => {
+                return resolve(Buffer.concat(buffers));
+            });
+            stream.on('error', reject);
+            stream.read();
+        });
+    }
+    startup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.logger.isDebugEnabled()) {
+                this.logger.info(`${this.constructor.name} is startup`);
+            }
+        });
+    }
+    upload(path, buffer, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.logger.isDebugEnabled()) {
+                this.logger.info(`${this.constructor.name} upload ${path}`);
+            }
+            return path;
+        });
+    }
+    download(path, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.logger.isDebugEnabled()) {
+                this.logger.info(`${this.constructor.name} download ${path}`);
+            }
+            return null;
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.logger.isDebugEnabled()) {
+                this.logger.info(`${this.constructor.name} access ${path}`);
+            }
+            return '';
+        });
+    }
+}
+exports.Dfs = Dfs;

package/lib/fastdfs.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Dfs, FastdfsConfig } from "./declare";
+import { VWebApplicationContext } from "vweb-core";
+export default class HttpDfs extends Dfs<'fastdfs'> {
+    private client;
+    constructor(options: FastdfsConfig & {
+        type: 'fastdfs';
+    }, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/fastdfs.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const declare_1 = require("./declare");
+const axios_1 = __importDefault(require("axios"));
+const vweb_core_1 = require("vweb-core");
+const form_data_1 = __importDefault(require("form-data"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class HttpDfs extends declare_1.Dfs {
+    constructor(options, context) {
+        super(Object.assign({ group: 'group1' }, options), context);
+        this.client = axios_1.default.create();
+    }
+    startup() {
+        const _super = Object.create(null, {
+            startup: { get: () => super.startup }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.startup.call(this);
+        });
+    }
+    upload(path, buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`upload ${path}`);
+                let { name, dir, ext } = path_1.default.parse(path);
+                let tmpFile = this.getTmpFile(`${vweb_core_1.util.snowflake.nextId()}${ext}`);
+                fs_1.default.writeFileSync(tmpFile, buffer);
+                const { domain, group, token } = this.options;
+                let form = new form_data_1.default();
+                form.append('file', fs_1.default.createReadStream(tmpFile));
+                form.append('filename', `${name}${ext}`);
+                if (token) {
+                    form.append('auth_token', token);
+                }
+                form.append('path', dir);
+                let headers = form.getHeaders();
+                return new Promise((resolve, reject) => {
+                    form.getLength((err, length) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        headers['contentLength'] = length;
+                        axios_1.default.post(`${domain}/${group}/upload`, form, {
+                            maxContentLength: Infinity,
+                            maxBodyLength: Infinity,
+                            headers
+                        }).then(({ data }) => {
+                            resolve(path);
+                        }).catch(err => {
+                            reject(err);
+                        }).finally(() => {
+                            if (fs_1.default.existsSync(tmpFile)) {
+                                fs_1.default.rmSync(tmpFile);
+                            }
+                        });
+                    });
+                });
+            }
+            finally {
+                this.timeEnd(`upload ${path}`);
+            }
+        });
+    }
+    download(path, ...args) {
+        const _super = Object.create(null, {
+            download: { get: () => super.download }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { domain, group } = this.options;
+                this.timeBegin(`download ${path}`);
+                const { status, data } = yield axios_1.default.get(`${domain}/${group}${path}`, { responseType: 'arraybuffer' });
+                yield _super.download.call(this, path, ...args);
+                return data;
+            }
+            catch (e) {
+                this.logger.error(`download ${path} error >>> ${e.message}`);
+            }
+            finally {
+                this.timeEnd(`download ${path}`);
+            }
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.access) {
+                return `${this.options.access}/dfs/get?filename=${path}`;
+            }
+            const { domain, group } = this.options;
+            return `${domain}/${group}${path}`;
+        });
+    }
+}
+exports.default = HttpDfs;

package/lib/http.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Dfs, HttpConfig } from "./declare";
+import { VWebApplicationContext } from "vweb-core";
+export default class HttpDfs extends Dfs<'http'> {
+    private client;
+    constructor(options: HttpConfig & {
+        type: 'http';
+    }, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/http.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const declare_1 = require("./declare");
+const axios_1 = __importDefault(require("axios"));
+const vweb_core_1 = require("vweb-core");
+const form_data_1 = __importDefault(require("form-data"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+class HttpDfs extends declare_1.Dfs {
+    constructor(options, context) {
+        super(options, context);
+        this.client = axios_1.default.create({
+            headers: options.headers
+        });
+    }
+    startup() {
+        const _super = Object.create(null, {
+            startup: { get: () => super.startup }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.startup.call(this);
+        });
+    }
+    upload(path, buffer, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`upload ${path}`);
+                let { name, dir, ext } = path_1.default.parse(path);
+                let tmpFile = this.getTmpFile(`${vweb_core_1.util.snowflake.nextId()}${ext}`);
+                fs_1.default.writeFileSync(tmpFile, buffer);
+                let form = new form_data_1.default();
+                form.append('file', fs_1.default.createReadStream(tmpFile));
+                form.append('filename', `${name}${ext}`);
+                form.append('path', path);
+                let headers = form.getHeaders();
+                return new Promise((resolve, reject) => {
+                    form.getLength((err, length) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        headers['contentLength'] = length;
+                        axios_1.default.post(this.options.url, form, {
+                            maxContentLength: Infinity,
+                            maxBodyLength: Infinity,
+                            headers,
+                            params: this.options.body
+                        }).then(({ data }) => {
+                            resolve(path);
+                        }).catch(err => {
+                            reject(err);
+                        }).finally(() => {
+                            if (fs_1.default.existsSync(tmpFile)) {
+                                fs_1.default.rmSync(tmpFile);
+                            }
+                        });
+                    });
+                });
+            }
+            finally {
+                this.timeEnd(`upload ${path}`);
+            }
+        });
+    }
+    download(path, ...args) {
+        const _super = Object.create(null, {
+            download: { get: () => super.download }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`download ${path}`);
+                const { data } = yield axios_1.default.get(this.options.url, {
+                    params: Object.assign({ filename: path }, this.options.body),
+                    responseType: 'arraybuffer'
+                });
+                yield _super.download.call(this, path, ...args);
+                return data;
+            }
+            finally {
+                this.timeEnd(`download ${path}`);
+            }
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.access) {
+                return `${this.options.access}/dfs/get?filename=${path}`;
+            }
+            return `${this.options.url}?filename=${path}`;
+        });
+    }
+}
+exports.default = HttpDfs;

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+import { DfsConfig } from "./declare";
+import Mdfs from "./mdfs";
+export * from './declare';
+declare global {
+    const dfs: Mdfs;
+    interface Object {
+        readonly dfs: Mdfs;
+    }
+}
+declare const _default: {
+    name: string;
+    launch: (config: DfsConfig) => Mdfs;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mdfs_1 = __importDefault(require("./mdfs"));
+__exportStar(require("./declare"), exports);
+exports.default = {
+    name: 'dfs',
+    launch: function (config) {
+        return new mdfs_1.default(config, this);
+    }
+};

package/lib/mdfs.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { VWebApplicationContext } from "vweb-core";
+import { ConfigOptionsKey, Dfs, DfsConfig } from "./declare";
+export default class Mdfs extends Dfs<ConfigOptionsKey> {
+    private dfs;
+    private readonly config;
+    constructor(config: DfsConfig, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/mdfs.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vweb_core_1 = require("vweb-core");
+const declare_1 = require("./declare");
+class MDFSHttpListenerWrapper {
+    constructor() {
+        this.annotation = {
+            type: "controller",
+            component: true,
+            name: `MDFSHttpListener${vweb_core_1.util.snowflake.nextId()}Controller`,
+            mapping: { value: "dfs", method: "all" },
+            mappings: {
+                get: [{ value: 'get', method: "get" }]
+            }
+        };
+    }
+    get(filename, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { name, ext } = require('path').parse(filename);
+            res.attachment(`${name}${ext}`);
+            return this.dfs.download(filename);
+        });
+    }
+}
+class Mdfs extends declare_1.Dfs {
+    constructor(config, context) {
+        super(config, context);
+        this.config = config;
+        context.trusteeship(new MDFSHttpListenerWrapper());
+        const _a = this.config, { type } = _a, options = __rest(_a, ["type"]);
+        let Type = require(`./${type}`).default;
+        this.dfs = new Type(options, context);
+    }
+    startup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dfs.startup();
+        });
+    }
+    upload(path, buffer, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dfs.upload(path, buffer, ...args);
+        });
+    }
+    download(path, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dfs.download(path, ...args);
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dfs.getAccess(path);
+        });
+    }
+}
+exports.default = Mdfs;

package/lib/minio.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Dfs, MinioConfig } from "./declare";
+import { VWebApplicationContext } from "vweb-core";
+export default class MinioDfs extends Dfs<'minio'> {
+    private client;
+    constructor(options: MinioConfig & {
+        type: 'minio';
+    }, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/minio.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const declare_1 = require("./declare");
+const minio = __importStar(require("minio"));
+class MinioDfs extends declare_1.Dfs {
+    constructor(options, context) {
+        super(Object.assign({ accessKey: '', secretKey: '' }, options), context);
+        this.client = new minio.Client(this.options);
+    }
+    startup() {
+        const _super = Object.create(null, {
+            startup: { get: () => super.startup }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.startup.call(this);
+        });
+    }
+    upload(path, buffer, ...args) {
+        const _super = Object.create(null, {
+            upload: { get: () => super.upload }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`upload ${path}`);
+                this.client.putObject(this.options.bucketName, path, buffer, ...args);
+                return _super.upload.call(this, path, buffer, ...args);
+            }
+            finally {
+                this.timeEnd(`upload ${path}`);
+            }
+        });
+    }
+    download(path, ...args) {
+        const _super = Object.create(null, {
+            download: { get: () => super.download }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`download ${path}`);
+                yield _super.download.call(this, path, ...args);
+                let stream = yield this.client.getObject(this.options.bucketName, path);
+                return yield this.stream2buffer(stream);
+            }
+            finally {
+                this.timeEnd(`download ${path}`);
+            }
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.access) {
+                return `${this.options.access}/dfs/get?filename=${path}`;
+            }
+            return `http://${this.options.endPoint}:${this.options.port}/${this.options.bucketName}${path}`;
+        });
+    }
+}
+exports.default = MinioDfs;

package/lib/native.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Dfs, NativeConfig } from "./declare";
+import { VWebApplicationContext } from "vweb-core";
+export default class NativeDfs extends Dfs<'native'> {
+    constructor(options: NativeConfig & {
+        type: 'native';
+    }, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/native.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const declare_1 = require("./declare");
+const fs = __importStar(require("fs"));
+class NativeDfs extends declare_1.Dfs {
+    constructor(options, context) {
+        super(options, context);
+    }
+    startup() {
+        const _super = Object.create(null, {
+            startup: { get: () => super.startup }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.startup.call(this);
+        });
+    }
+    upload(path, buffer, ...args) {
+        const _super = Object.create(null, {
+            upload: { get: () => super.upload }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`upload ${path}`);
+                fs.writeFileSync(`${this.options.storage}${path}`, buffer);
+                return _super.upload.call(this, path, buffer, ...args);
+            }
+            finally {
+                this.timeEnd(`upload ${path}`);
+            }
+        });
+    }
+    download(path, ...args) {
+        const _super = Object.create(null, {
+            download: { get: () => super.download }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`download ${path}`);
+                yield _super.download.call(this, path, ...args);
+                return fs.readFileSync(`${this.options.storage}${path}`);
+            }
+            finally {
+                this.timeEnd(`download ${path}`);
+            }
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return `${this.options.access}/dfs/get?filename=${path}`;
+        });
+    }
+}
+exports.default = NativeDfs;

package/lib/oss.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Dfs, OssConfig } from "./declare";
+import { VWebApplicationContext } from "vweb-core";
+export default class OssDfs extends Dfs<'oss'> {
+    private readonly client;
+    constructor(options: OssConfig & {
+        type: 'oss';
+    }, context: VWebApplicationContext);
+    startup(): Promise<void>;
+    upload(path: string, buffer: any, ...args: any[]): Promise<string>;
+    download(path: string, ...args: any[]): Promise<Buffer>;
+    getAccess(path: string): Promise<string>;
+}

package/lib/oss.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const declare_1 = require("./declare");
+const ali_oss_1 = __importDefault(require("ali-oss"));
+const fs_1 = __importDefault(require("fs"));
+class OssDfs extends declare_1.Dfs {
+    constructor(options, context) {
+        super(options, context);
+        this.client = new ali_oss_1.default(options);
+    }
+    startup() {
+        const _super = Object.create(null, {
+            startup: { get: () => super.startup }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.startup.call(this);
+        });
+    }
+    upload(path, buffer, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`upload ${path}`);
+                let result;
+                if (buffer.constructor.name === 'Buffer') {
+                    result = yield this.client.put(path, buffer, ...args);
+                }
+                else if (typeof buffer === 'string') {
+                    if (fs_1.default.existsSync(buffer)) {
+                        result = yield this.client.put(path, buffer, ...args);
+                    }
+                    else {
+                        result = yield this.client.put(path, Buffer.from(buffer), ...args);
+                    }
+                }
+                else {
+                    result = yield this.client.putStream(path, buffer, ...args);
+                }
+                return path;
+            }
+            finally {
+                this.timeEnd(`upload ${path}`);
+            }
+        });
+    }
+    download(path, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.timeBegin(`download ${path}`);
+                const result = yield this.client.getStream(path, ...args);
+                return this.stream2buffer(result.stream);
+            }
+            finally {
+                this.timeEnd(`download ${path}`);
+            }
+        });
+    }
+    getAccess(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.options.access) {
+                return `${this.options.access}/dfs/get?filename=${path}`;
+            }
+            return this.client.getObjectUrl(path, this.options.access);
+        });
+    }
+}
+exports.default = OssDfs;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dfs-adapter",
+  "version": "0.0.1",
+  "description": "oss minio dfs native",
+  "main": "./lib/index",
+  "files": [
+    "lib/"
+  ],
+  "scripts": {
+    "test": "node bin/app.js",
+    "build": "tsc --build tsconfig.json",
+    "run": "npm run build && node bin/app.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@codeup.aliyun.com:60b0836844816b8ed2335ed6/vweb/modules/mq-adapter.git"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/plugin-proposal-decorators": "^7.16.4",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.16.4",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/register": "^7.16.0",
+    "@babel/runtime": "^7.16.3",
+    "@types/ali-oss": "^6.16.3",
+    "@types/node": "^16.11.12",
+    "ali-oss": "^6.18.1",
+    "axios": "^1.6.1",
+    "babel-plugin-transform-decorators-legacy": "^1.3.5",
+    "form-data": "^4.0.0",
+    "minio": "^7.1.3",
+    "vweb-core": "^3.0.14",
+    "vweb-mvc": "^1.2.18"
+  },
+  "author": "",
+  "license": "ISC"
+}