@eggjs/core 6.0.0-beta.0

package/dist/esm/loader/file_loader.d.ts

@@ -0,0 +1,96 @@
+import { Fun } from '../utils/index.js';
+export declare const FULLPATH: unique symbol;
+export declare const EXPORTS: unique symbol;
+export type CaseStyle = 'camel' | 'lower' | 'upper';
+export type CaseStyleFunction = (filepath: string) => string[];
+export type FileLoaderInitializer = (exports: unknown, options: {
+    path: string;
+    pathName: string;
+}) => unknown;
+export type FileLoaderFilter = (exports: unknown) => boolean;
+export interface FileLoaderOptions {
+    /** directories to be loaded */
+    directory: string | string[];
+    /** attach the target object from loaded files */
+    target: Record<string, any>;
+    /** match the files when load, support glob, default to all js files */
+    match?: string | string[];
+    /** ignore the files when load, support glob */
+    ignore?: string | string[];
+    /** custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path` */
+    initializer?: FileLoaderInitializer;
+    /** determine whether invoke when exports is function */
+    call?: boolean;
+    /** determine whether override the property when get the same name */
+    override?: boolean;
+    /** an object that be the argument when invoke the function */
+    inject?: Record<string, any>;
+    /** a function that filter the exports which can be loaded */
+    filter?: FileLoaderFilter;
+    /** set property's case when converting a filepath to property list. */
+    caseStyle?: CaseStyle | CaseStyleFunction;
+    lowercaseFirst?: boolean;
+}
+export interface FileLoaderParseItem {
+    fullpath: string;
+    properties: string[];
+    exports: object | Fun;
+}
+/**
+ * Load files from directory to target object.
+ * @since 1.0.0
+ */
+export declare class FileLoader {
+    static get FULLPATH(): symbol;
+    static get EXPORTS(): symbol;
+    readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, 'caseStyle'>>;
+    /**
+     * @class
+     * @param {Object} options - options
+     * @param {String|Array} options.directory - directories to be loaded
+     * @param {Object} options.target - attach the target object from loaded files
+     * @param {String} options.match - match the files when load, support glob, default to all js files
+     * @param {String} options.ignore - ignore the files when load, support glob
+     * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+     * @param {Boolean} options.call - determine whether invoke when exports is function
+     * @param {Boolean} options.override - determine whether override the property when get the same name
+     * @param {Object} options.inject - an object that be the argument when invoke the function
+     * @param {Function} options.filter - a function that filter the exports which can be loaded
+     * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+     */
+    constructor(options: FileLoaderOptions);
+    /**
+     * attach items to target object. Mapping the directory to properties.
+     * `app/controller/group/repository.js` => `target.group.repository`
+     * @return {Object} target
+     * @since 1.0.0
+     */
+    load(): Promise<object>;
+    /**
+     * Parse files from given directories, then return an items list, each item contains properties and exports.
+     *
+     * For example, parse `app/controller/group/repository.js`
+     *
+     * ```
+     * module.exports = app => {
+     *   return class RepositoryController extends app.Controller {};
+     * }
+     * ```
+     *
+     * It returns a item
+     *
+     * ```
+     * {
+     *   properties: [ 'group', 'repository' ],
+     *   exports: app => { ... },
+     * }
+     * ```
+     *
+     * `Properties` is an array that contains the directory of a filepath.
+     *
+     * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+     * @return {Array} items
+     * @since 1.0.0
+     */
+    protected parse(): Promise<FileLoaderParseItem[]>;
+}

package/dist/esm/loader/file_loader.js

@@ -0,0 +1,241 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import globby from 'globby';
+import { isClass, isGeneratorFunction, isAsyncFunction, isPrimitive } from 'is-type-of';
+import utils from '../utils/index.js';
+const debug = debuglog('@eggjs/core:file_loader');
+export const FULLPATH = Symbol('EGG_LOADER_ITEM_FULLPATH');
+export const EXPORTS = Symbol('EGG_LOADER_ITEM_EXPORTS');
+/**
+ * Load files from directory to target object.
+ * @since 1.0.0
+ */
+export class FileLoader {
+    static get FULLPATH() {
+        return FULLPATH;
+    }
+    static get EXPORTS() {
+        return EXPORTS;
+    }
+    options;
+    /**
+     * @class
+     * @param {Object} options - options
+     * @param {String|Array} options.directory - directories to be loaded
+     * @param {Object} options.target - attach the target object from loaded files
+     * @param {String} options.match - match the files when load, support glob, default to all js files
+     * @param {String} options.ignore - ignore the files when load, support glob
+     * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+     * @param {Boolean} options.call - determine whether invoke when exports is function
+     * @param {Boolean} options.override - determine whether override the property when get the same name
+     * @param {Object} options.inject - an object that be the argument when invoke the function
+     * @param {Function} options.filter - a function that filter the exports which can be loaded
+     * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+     */
+    constructor(options) {
+        assert(options.directory, 'options.directory is required');
+        assert(options.target, 'options.target is required');
+        this.options = {
+            caseStyle: 'camel',
+            call: true,
+            override: false,
+            ...options,
+        };
+        // compatible old options _lowercaseFirst_
+        if (this.options.lowercaseFirst === true) {
+            utils.deprecated('lowercaseFirst is deprecated, use caseStyle instead');
+            this.options.caseStyle = 'lower';
+        }
+    }
+    /**
+     * attach items to target object. Mapping the directory to properties.
+     * `app/controller/group/repository.js` => `target.group.repository`
+     * @return {Object} target
+     * @since 1.0.0
+     */
+    async load() {
+        const items = await this.parse();
+        const target = this.options.target;
+        for (const item of items) {
+            debug('loading item: %o', item);
+            // item { properties: [ 'a', 'b', 'c'], exports }
+            // => target.a.b.c = exports
+            item.properties.reduce((target, property, index) => {
+                let obj;
+                const properties = item.properties.slice(0, index + 1).join('.');
+                if (index === item.properties.length - 1) {
+                    if (property in target) {
+                        if (!this.options.override)
+                            throw new Error(`can't overwrite property '${properties}' from ${target[property][FULLPATH]} by ${item.fullpath}`);
+                    }
+                    obj = item.exports;
+                    if (obj && !isPrimitive(obj)) {
+                        Reflect.set(obj, FULLPATH, item.fullpath);
+                        Reflect.set(obj, EXPORTS, true);
+                    }
+                }
+                else {
+                    obj = target[property] || {};
+                }
+                target[property] = obj;
+                debug('loaded item properties: %o => %o', properties, obj);
+                return obj;
+            }, target);
+        }
+        return target;
+    }
+    /**
+     * Parse files from given directories, then return an items list, each item contains properties and exports.
+     *
+     * For example, parse `app/controller/group/repository.js`
+     *
+     * ```
+     * module.exports = app => {
+     *   return class RepositoryController extends app.Controller {};
+     * }
+     * ```
+     *
+     * It returns a item
+     *
+     * ```
+     * {
+     *   properties: [ 'group', 'repository' ],
+     *   exports: app => { ... },
+     * }
+     * ```
+     *
+     * `Properties` is an array that contains the directory of a filepath.
+     *
+     * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+     * @return {Array} items
+     * @since 1.0.0
+     */
+    async parse() {
+        let files = this.options.match;
+        if (!files) {
+            files = (process.env.EGG_TYPESCRIPT === 'true' && utils.extensions['.ts'])
+                ? ['**/*.(js|ts)', '!**/*.d.ts']
+                : ['**/*.js'];
+        }
+        else {
+            files = Array.isArray(files) ? files : [files];
+        }
+        let ignore = this.options.ignore;
+        if (ignore) {
+            ignore = Array.isArray(ignore) ? ignore : [ignore];
+            ignore = ignore.filter(f => !!f).map(f => '!' + f);
+            files = files.concat(ignore);
+        }
+        let directories = this.options.directory;
+        if (!Array.isArray(directories)) {
+            directories = [directories];
+        }
+        const filter = typeof this.options.filter === 'function' ? this.options.filter : null;
+        const items = [];
+        debug('[parse] parsing directories: %j', directories);
+        for (const directory of directories) {
+            const filepaths = globby.sync(files, { cwd: directory });
+            debug('[parse] globby files: %o, cwd: %o => %o', files, directory, filepaths);
+            for (const filepath of filepaths) {
+                const fullpath = path.join(directory, filepath);
+                if (!fs.statSync(fullpath).isFile())
+                    continue;
+                // get properties
+                // app/service/foo/bar.js => [ 'foo', 'bar' ]
+                const properties = getProperties(filepath, this.options.caseStyle);
+                // app/service/foo/bar.js => service.foo.bar
+                const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
+                // get exports from the file
+                const exports = await getExports(fullpath, this.options, pathName);
+                // ignore exports when it's null or false returned by filter function
+                if (exports == null || (filter && filter(exports) === false)) {
+                    continue;
+                }
+                // set properties of class
+                if (isClass(exports)) {
+                    exports.prototype.pathName = pathName;
+                    exports.prototype.fullPath = fullpath;
+                }
+                items.push({ fullpath, properties, exports });
+                debug('[parse] parse %s, properties %j, exports %o', fullpath, properties, exports);
+            }
+        }
+        return items;
+    }
+}
+// convert file path to an array of properties
+// a/b/c.js => ['a', 'b', 'c']
+function getProperties(filepath, caseStyle) {
+    // if caseStyle is function, return the result of function
+    if (typeof caseStyle === 'function') {
+        const result = caseStyle(filepath);
+        assert(Array.isArray(result), `caseStyle expect an array, but got ${JSON.stringify(result)}`);
+        return result;
+    }
+    // use default camelize
+    return defaultCamelize(filepath, caseStyle);
+}
+// Get exports from filepath
+// If exports is null/undefined, it will be ignored
+async function getExports(fullpath, options, pathName) {
+    let exports = await utils.loadFile(fullpath);
+    // process exports as you like
+    if (options.initializer) {
+        exports = options.initializer(exports, { path: fullpath, pathName });
+        debug('[getExports] after initializer => %o', exports);
+    }
+    if (isGeneratorFunction(exports)) {
+        throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
+    }
+    // return exports when it's a class or async function
+    //
+    // module.exports = class Service {};
+    // or
+    // module.exports = async function() {}
+    if (isClass(exports) || isAsyncFunction(exports)) {
+        return exports;
+    }
+    // return exports after call when it's a function
+    //
+    // module.exports = function(app) {
+    //   return {};
+    // }
+    if (options.call && typeof exports === 'function') {
+        exports = exports(options.inject);
+        if (exports != null) {
+            return exports;
+        }
+    }
+    // return exports what is
+    return exports;
+}
+function defaultCamelize(filepath, caseStyle) {
+    const properties = filepath.substring(0, filepath.lastIndexOf('.')).split('/');
+    return properties.map(property => {
+        if (!/^[a-z][a-z0-9_-]*$/i.test(property)) {
+            throw new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`);
+        }
+        // use default camelize, will capitalize the first letter
+        // foo_bar.js > FooBar
+        // fooBar.js  > FooBar
+        // FooBar.js  > FooBar
+        // FooBar.js  > FooBar
+        // FooBar.js  > fooBar (if lowercaseFirst is true)
+        property = property.replace(/[_-][a-z]/ig, s => s.substring(1).toUpperCase());
+        let first = property[0];
+        switch (caseStyle) {
+            case 'lower':
+                first = first.toLowerCase();
+                break;
+            case 'upper':
+                first = first.toUpperCase();
+                break;
+            case 'camel':
+            default:
+        }
+        return first + property.substring(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file_loader.js","sourceRoot":"","sources":["../../../src/loader/file_loader.ts"],"names":[],"mappings":"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"}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/types.d.ts

@@ -0,0 +1 @@
+export {};