@builder6/moleculer 0.5.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jiangzhuo 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# nestjs-moleculer
+[Moleculer](https://github.com/moleculerjs/moleculer) Module For [Nestjs](https://github.com/nestjs/nest) Framework
+
+## Why ?
+
+Nestjs and Moleculer are amazing framework for building server-side application. They have different advantages. This module allow bring elegent micoservice API from Moleculer to Nestjs. 
+
+## How ?
+
+This module works like other Nestjs third-party module. You can use it in NestApplication, without creating NestMicroservice instance. 
+using `InjectBroker` to inject Moleculer Broker.
+using `InjectService` to inject Moleculer Service.
+
+## Install
+
+IMPORTANT: you need Nest > v4.5.10+
+
+```bash
+npm install @builder6/moleculer --save
+```
+
+OR
+
+```bash
+yarn add @builder6/moleculer
+```
+
+## Setup
+
+### Init Module
+
+```ts
+... //imports
+@Module({
+    imports: [
+          MoleculerModule.forRoot({
+              brokerName: "customBrokerName", // if you have multiple broker
+              namespace: "yourNameSpace", // some moleculer options
+              transporter: "TCP",
+              // hotReload: true, // hotReload feature from moleculer will not work 
+          })
+          OtherModule
+    ],
+    controllers: [
+        homeController, // controller that extrends Moleculer Service
+    ],
+    // as usual, nothing new
+})
+export class ApplicationModule {}
+```
+
+### Declare Moleculer Service (as controller)
+
+```ts
+import { Service, Context, ServiceBroker } from 'moleculer';
+import { Inject, Injectable } from '@nestjs/common';
+import { HomeService } from "../services/home.service";
+import { InjectBroker } from 'nestjs-moleculer';
+
+@Injectable()
+export class HomeController extends Service {
+    constructor(@InjectBroker() broker: ServiceBroker,
+                @Inject(HomeService) private readonly homeService: HomeService
+    ) {
+        super(broker);
+
+        this.parseServiceSchema({
+            name: "home",
+            settings: {
+                upperCase: true
+            },
+            actions: {
+                sayHello: this.sayHello,
+            },
+            created: this.serviceCreated,
+            started: this.serviceStarted,
+            stopped: this.serviceStopped,
+        });
+    }
+
+    serviceCreated() {
+        this.logger.info("home service created.");
+    }
+
+    serviceStarted() {
+        this.logger.info("home service started.");
+    }
+
+    serviceStopped() {
+        this.logger.info("home service stopped.");
+    }
+
+    async sayHello(ctx: Context) {
+        return this.homeService.sayHello(ctx.params.name);
+    }
+}
+
+```
+for more detail of [How to declare Moleculre Service in ES6 Class](https://github.com/moleculerjs/moleculer/blob/d848389105619fe9e588a5a4ce75bb833b2442df/examples/es6.class.service.js)
+
+### Call Service Handler
+```ts
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { InjectBroker } from "nestjs-moleculer";
+
+import { ServiceBroker } from "moleculer";
+
+@Injectable()
+export class AppService {
+    constructor(
+        @InjectBroker() private readonly broker: ServiceBroker,
+    ) {
+    }
+
+    onModuleInit() {
+        setTimeout(() => {
+            this.broker.call('home.sayHello', { name: "jiangzhuo" }).then((res) => {
+                console.log(res)
+            })
+        }, 1000)
+    }
+}
+
+
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

package/dist/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './moleculer.decorators';
+export { getBrokerToken, getServiceToken } from './moleculer.utils';

package/dist/common/index.js

@@ -0,0 +1,21 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceToken = exports.getBrokerToken = void 0;
+__exportStar(require("./moleculer.decorators"), exports);
+var moleculer_utils_1 = require("./moleculer.utils");
+Object.defineProperty(exports, "getBrokerToken", { enumerable: true, get: function () { return moleculer_utils_1.getBrokerToken; } });
+Object.defineProperty(exports, "getServiceToken", { enumerable: true, get: function () { return moleculer_utils_1.getServiceToken; } });

package/dist/common/moleculer.decorators.d.ts

@@ -0,0 +1,2 @@
+export declare const InjectService: (name: string) => (target: object, key: string | symbol | undefined, index?: number) => void;
+export declare const InjectBroker: (name?: string) => (target: object, key: string | symbol | undefined, index?: number) => void;

package/dist/common/moleculer.decorators.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectBroker = exports.InjectService = void 0;
+const common_1 = require("@nestjs/common");
+const moleculer_constants_1 = require("../moleculer.constants");
+const moleculer_utils_1 = require("./moleculer.utils");
+const InjectService = (name) => (0, common_1.Inject)((0, moleculer_utils_1.getServiceToken)(name));
+exports.InjectService = InjectService;
+const InjectBroker = (name) => (0, common_1.Inject)(name ? (0, moleculer_utils_1.getBrokerToken)(name) : moleculer_constants_1.DEFAULT_BROKER);
+exports.InjectBroker = InjectBroker;

package/dist/common/moleculer.utils.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+export declare function getServiceToken(name: string): string;
+export declare function getBrokerToken(name: string): string;
+export declare function handleRetry(retryAttempts?: number, retryDelay?: number): <T>(source: Observable<T>) => Observable<T>;

package/dist/common/moleculer.utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceToken = getServiceToken;
+exports.getBrokerToken = getBrokerToken;
+exports.handleRetry = handleRetry;
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+function getServiceToken(name) {
+    return `${name}|MoleculerService`;
+}
+function getBrokerToken(name) {
+    return `${name}|MoleculerBroker`;
+}
+function handleRetry(retryAttempts = 9, retryDelay = 3000) {
+    return (source) => source.pipe((0, operators_1.retryWhen)(e => e.pipe((0, operators_1.scan)((errorCount, error) => {
+        common_1.Logger.error(`Unable to connect to the database. Retrying (${errorCount +
+            1})...`, '', 'MongooseModule');
+        if (errorCount + 1 >= retryAttempts) {
+            throw error;
+        }
+        return errorCount + 1;
+    }, 0), (0, operators_1.delay)(retryDelay))));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './interfaces';
+export * from './moleculer.module';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./moleculer.module"), exports);

package/dist/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './moleculer-options.interface';

package/dist/interfaces/index.js

@@ -0,0 +1,17 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./moleculer-options.interface"), exports);

package/dist/interfaces/moleculer-options.interface.d.ts

@@ -0,0 +1,16 @@
+import { Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+export interface MoleculerModuleOptions {
+    [key: string]: any;
+    brokerName?: string;
+}
+export interface MoleculerOptionsFactory {
+    createMoleculerOptions(): Promise<MoleculerModuleOptions> | MoleculerModuleOptions;
+}
+export interface MoleculerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    brokerName?: string;
+    useExisting?: Type<MoleculerOptionsFactory>;
+    useClass?: Type<MoleculerOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<MoleculerModuleOptions> | MoleculerModuleOptions;
+    inject?: any[];
+}

package/dist/interfaces/moleculer-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/moleculer-core.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { MoleculerModuleAsyncOptions, MoleculerModuleOptions } from './interfaces/moleculer-options.interface';
+export declare class MoleculerCoreModule {
+    private readonly brokerName;
+    private readonly moduleRef;
+    constructor(brokerName: string, moduleRef: ModuleRef);
+    static forRoot(options?: MoleculerModuleOptions): DynamicModule;
+    static forRootAsync(options: MoleculerModuleAsyncOptions): DynamicModule;
+    onModuleDestroy(): Promise<void>;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/dist/moleculer-core.module.js

@@ -0,0 +1,124 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var MoleculerCoreModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoleculerCoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rxjs_1 = require("rxjs");
+const moleculer_utils_1 = require("./common/moleculer.utils");
+const moleculer_constants_1 = require("./moleculer.constants");
+const moleculer_1 = require("moleculer");
+let MoleculerCoreModule = MoleculerCoreModule_1 = class MoleculerCoreModule {
+    constructor(brokerName, moduleRef) {
+        this.brokerName = brokerName;
+        this.moduleRef = moduleRef;
+    }
+    static forRoot(options = {}) {
+        const { retryAttempts, retryDelay, brokerName, ...moleculerOptions } = options;
+        const moleculerBrokerName = brokerName
+            ? (0, moleculer_utils_1.getBrokerToken)(brokerName)
+            : moleculer_constants_1.DEFAULT_BROKER;
+        const moleculerBrokerNameProvider = {
+            provide: moleculer_constants_1.MOLECULER_BROKER_NAME,
+            useValue: moleculerBrokerName,
+        };
+        const brokerProvider = {
+            provide: moleculerBrokerName,
+            useFactory: async () => await (0, rxjs_1.defer)(async () => new moleculer_1.ServiceBroker(moleculerOptions))
+                .pipe((0, moleculer_utils_1.handleRetry)(retryAttempts, retryDelay))
+                .toPromise()
+                .then(broker => {
+                broker.start();
+                return broker;
+            }),
+        };
+        return {
+            module: MoleculerCoreModule_1,
+            providers: [brokerProvider, moleculerBrokerNameProvider],
+            exports: [brokerProvider],
+        };
+    }
+    static forRootAsync(options) {
+        const moleculerBrokerName = options.brokerName
+            ? (0, moleculer_utils_1.getBrokerToken)(options.brokerName)
+            : moleculer_constants_1.DEFAULT_BROKER;
+        const moleculerBrokerNameProvider = {
+            provide: moleculer_constants_1.MOLECULER_BROKER_NAME,
+            useValue: moleculerBrokerName,
+        };
+        const brokerProvider = {
+            provide: moleculerBrokerName,
+            useFactory: async (moleculerModuleOptions) => {
+                const { retryAttempts, retryDelay, brokerName, ...moleculerOptions } = moleculerModuleOptions;
+                return await (0, rxjs_1.defer)(async () => new moleculer_1.ServiceBroker(moleculerOptions))
+                    .pipe((0, moleculer_utils_1.handleRetry)(moleculerModuleOptions.retryAttempts, moleculerModuleOptions.retryDelay))
+                    .toPromise()
+                    .then(broker => {
+                    broker.start();
+                    return broker;
+                });
+            },
+            inject: [moleculer_constants_1.MOLECULER_MODULE_OPTIONS],
+        };
+        const asyncProviders = this.createAsyncProviders(options);
+        return {
+            module: MoleculerCoreModule_1,
+            imports: options.imports,
+            providers: [
+                ...asyncProviders,
+                brokerProvider,
+                moleculerBrokerNameProvider,
+            ],
+            exports: [brokerProvider],
+        };
+    }
+    async onModuleDestroy() {
+        const broker = this.moduleRef.get(this.brokerName);
+        broker && (await broker.stop());
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: moleculer_constants_1.MOLECULER_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: moleculer_constants_1.MOLECULER_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => await optionsFactory.createMoleculerOptions(),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+exports.MoleculerCoreModule = MoleculerCoreModule;
+exports.MoleculerCoreModule = MoleculerCoreModule = MoleculerCoreModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __param(0, (0, common_1.Inject)(moleculer_constants_1.MOLECULER_BROKER_NAME)),
+    __metadata("design:paramtypes", [String, core_1.ModuleRef])
+], MoleculerCoreModule);

package/dist/moleculer.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_BROKER = "MoleculerBroker";
+export declare const MOLECULER_MODULE_OPTIONS = "MoleculerModuleOptions";
+export declare const MOLECULER_BROKER_NAME = "MoleculerBrokerName";

package/dist/moleculer.constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOLECULER_BROKER_NAME = exports.MOLECULER_MODULE_OPTIONS = exports.DEFAULT_BROKER = void 0;
+exports.DEFAULT_BROKER = 'MoleculerBroker';
+exports.MOLECULER_MODULE_OPTIONS = 'MoleculerModuleOptions';
+exports.MOLECULER_BROKER_NAME = 'MoleculerBrokerName';

package/dist/moleculer.module.d.ts

@@ -0,0 +1,12 @@
+import { DynamicModule } from '@nestjs/common';
+import { MoleculerModuleAsyncOptions, MoleculerModuleOptions } from './interfaces/moleculer-options.interface';
+import { ServiceSchema } from 'moleculer';
+export declare class MoleculerModule {
+    static forRoot(options?: MoleculerModuleOptions): DynamicModule;
+    static forRootAsync(options: MoleculerModuleAsyncOptions): DynamicModule;
+    static forFeature(services?: {
+        name: string;
+        schema: ServiceSchema;
+        schemaMods?: ServiceSchema;
+    }[], brokerName?: string): DynamicModule;
+}

package/dist/moleculer.module.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MoleculerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoleculerModule = void 0;
+const common_1 = require("@nestjs/common");
+const moleculer_core_module_1 = require("./moleculer-core.module");
+const moleculer_constants_1 = require("./moleculer.constants");
+const moleculer_providers_1 = require("./moleculer.providers");
+let MoleculerModule = MoleculerModule_1 = class MoleculerModule {
+    static forRoot(options = {}) {
+        return {
+            module: MoleculerModule_1,
+            imports: [moleculer_core_module_1.MoleculerCoreModule.forRoot(options)],
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: MoleculerModule_1,
+            imports: [moleculer_core_module_1.MoleculerCoreModule.forRootAsync(options)],
+        };
+    }
+    static forFeature(services = [], brokerName = moleculer_constants_1.DEFAULT_BROKER) {
+        const providers = (0, moleculer_providers_1.createMoleculerProviders)(brokerName, services);
+        return {
+            module: MoleculerModule_1,
+            providers: providers,
+            exports: providers,
+        };
+    }
+};
+exports.MoleculerModule = MoleculerModule;
+exports.MoleculerModule = MoleculerModule = MoleculerModule_1 = __decorate([
+    (0, common_1.Module)({})
+], MoleculerModule);

package/dist/moleculer.providers.d.ts

@@ -0,0 +1,7 @@
+import { ServiceSchema } from 'moleculer';
+import { Provider } from '@nestjs/common';
+export declare function createMoleculerProviders(brokerName?: string, services?: {
+    name: string;
+    schema: ServiceSchema;
+    schemaMods?: ServiceSchema;
+}[]): Provider[];

package/dist/moleculer.providers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMoleculerProviders = createMoleculerProviders;
+const moleculer_utils_1 = require("./common/moleculer.utils");
+const moleculer_constants_1 = require("./moleculer.constants");
+function createMoleculerProviders(brokerName = moleculer_constants_1.DEFAULT_BROKER, services = []) {
+    const providers = (services || []).map(service => {
+        return {
+            provide: (0, moleculer_utils_1.getServiceToken)(service.name),
+            useFactory: (broker) => broker.createService(service.schema, service.schemaMods),
+            inject: [
+                brokerName === moleculer_constants_1.DEFAULT_BROKER
+                    ? moleculer_constants_1.DEFAULT_BROKER
+                    : (0, moleculer_utils_1.getBrokerToken)(brokerName),
+            ],
+        };
+    });
+    return providers;
+}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './dist';

package/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+exports.__esModule = true;
+__export(require("./dist"));

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@builder6/moleculer",
+  "version": "0.5.4",
+  "description": "using Moleculer as a Nest module",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "precommit": "lint-staged",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next"
+  },
+  "devDependencies": {
+    "moleculer": "^0.14.35",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^6.0.0",
+    "rxjs-compat": "^6.6.7"
+  },
+  "peerDependencies": {
+    "moleculer": "^0.14.35"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "e8a62cf2a20c2a4be6d05b6966d5afbfd5e95949"
+}