@chevre/domain 22.11.0-alpha.8 → 22.11.0

package/lib/chevre/service/taskHandler/onOperationFailed/informTaskIfNeeded.js

@@ -0,0 +1,105 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.informTaskIfNeeded = informTaskIfNeeded;
+const createDebug = require("debug");
+const factory = require("../../../factory");
+const debug = createDebug('chevre-domain:service:taskHandler:onOperationFailed');
+function createInformTasks(params) {
+    var _a, _b, _c;
+    const { task, setting, executionEndDate } = params;
+    const informTask = (_a = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _a === void 0 ? void 0 : _a.informTask;
+    const informTaskNames = (_b = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _b === void 0 ? void 0 : _b.informTaskNames;
+    const informTaskStatuses = (_c = setting === null || setting === void 0 ? void 0 : setting.onTaskStatusChanged) === null || _c === void 0 ? void 0 : _c.informTaskStatuses;
+    const informTasks = [];
+    if (Array.isArray(informTaskNames) && informTaskNames.includes(task.name)) {
+        if (Array.isArray(informTaskStatuses)) {
+            const { id, name, data, project, runsAt, remainingNumberOfTries } = task;
+            let task4inform;
+            if (remainingNumberOfTries <= 0) {
+                if (informTaskStatuses.includes(factory.taskStatus.Aborted)) {
+                    const abortingTask = {
+                        id, name, data, project, runsAt,
+                        status: factory.taskStatus.Aborted,
+                        typeOf: 'Task',
+                        dateAborted: executionEndDate
+                    };
+                    task4inform = abortingTask;
+                }
+            }
+            else {
+                if (informTaskStatuses.includes(factory.taskStatus.Running)) {
+                    const runningTask = {
+                        id, name, data, project, runsAt,
+                        status: factory.taskStatus.Running,
+                        typeOf: 'Task'
+                    };
+                    task4inform = runningTask;
+                }
+            }
+            if (task4inform !== undefined) {
+                const informIdentifier = `Task:${name}:${id}:${task4inform.status}`;
+                if (Array.isArray(informTask) && informTask.length > 0) {
+                    informTask.forEach((informTaskParams) => {
+                        var _a, _b;
+                        if (typeof ((_a = informTaskParams.recipient) === null || _a === void 0 ? void 0 : _a.url) === 'string') {
+                            const informActionAttributes = {
+                                object: task4inform,
+                                recipient: {
+                                    id: '',
+                                    name: String((_b = informTaskParams.recipient) === null || _b === void 0 ? void 0 : _b.name),
+                                    typeOf: factory.creativeWorkType.WebApplication
+                                },
+                                target: {
+                                    httpMethod: 'POST',
+                                    encodingType: factory.encodingFormat.Application.json,
+                                    typeOf: 'EntryPoint',
+                                    urlTemplate: informTaskParams.recipient.url
+                                },
+                                identifier: informIdentifier
+                            };
+                            const description = `inform aborting tasks to agg service: ${name} ${id} ${task4inform.status}`;
+                            informTasks.push({
+                                project,
+                                name: factory.taskName.TriggerWebhook,
+                                status: factory.taskStatus.Ready,
+                                runsAt: executionEndDate,
+                                remainingNumberOfTries: 10,
+                                numberOfTried: 0,
+                                executionResults: [],
+                                data: informActionAttributes,
+                                description
+                            });
+                        }
+                    });
+                }
+            }
+        }
+    }
+    return informTasks;
+}
+function informTaskIfNeeded(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const { executionEndDate, task } = params;
+        const isAborting = task.status === factory.taskStatus.Running;
+        const useInform = isAborting
+            && task.name !== factory.taskName.HandleNotification // nameで絞る
+            && task.name !== factory.taskName.TriggerWebhook;
+        if (useInform) {
+            const setting = yield repos.setting.findOne({ project: { id: { $eq: '*' } } }, ['onTaskStatusChanged']);
+            const informTasks = createInformTasks({ task, setting, executionEndDate });
+            debug('informTaskIfNeeded: creating inform tasks...', JSON.stringify(informTasks));
+            if (informTasks.length > 0) {
+                yield repos.task.saveMany(informTasks, { emitImmediately: true });
+            }
+        }
+    });
+}

package/lib/chevre/service/taskHandler/onOperationFailed.d.ts

@@ -0,0 +1,17 @@
+import type { INextFunction } from '../../eventEmitter/task';
+import * as factory from '../../factory';
+import type { SettingRepo } from '../../repo/setting';
+import type { IExecutableTask, TaskRepo } from '../../repo/task';
+/**
+ * タスク実行失敗時処理
+ */
+declare function onOperationFailed(params: {
+    task: IExecutableTask<factory.taskName>;
+    now: Date;
+    error: any;
+    next?: INextFunction;
+}): (repos: {
+    setting: SettingRepo;
+    task: TaskRepo;
+}) => Promise<void>;
+export { onOperationFailed };

package/lib/chevre/service/taskHandler/onOperationFailed.js

@@ -0,0 +1,70 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onOperationFailed = onOperationFailed;
+const factory = require("../../factory");
+const informTaskIfNeeded_1 = require("./onOperationFailed/informTaskIfNeeded");
+const USE_INFORM_TASK_RUNNING = process.env.USE_INFORM_TASK_RUNNING === '1';
+/**
+ * タスク実行失敗時処理
+ */
+function onOperationFailed(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        let error = params.error;
+        const { task, now, next } = params;
+        if (typeof error !== 'object') {
+            error = { message: String(error) };
+        }
+        const endDate = new Date();
+        // remainingNumberOfTries<=0ならAborted(2025-08-04~)
+        const isRetryable = task.remainingNumberOfTries > 0;
+        if (isRetryable) {
+            // 実験的に実行中タスク連携
+            if (USE_INFORM_TASK_RUNNING) {
+                yield (0, informTaskIfNeeded_1.informTaskIfNeeded)({ task, executionEndDate: endDate })(repos);
+            }
+            const result = {
+                executedAt: now,
+                endDate,
+                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
+            };
+            // 失敗してもここではステータスを戻さない(Runningのまま待機)
+            yield repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: task.status,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+        else {
+            // 分析連携(2025-08-05~)
+            // 設定されたnameの場合連携する
+            // もしここで連携タスク作成に失敗したとしても、再度Readyタスクとなりリトライされて、処理は冪等となる想定
+            // 最終的に、連携タスクが作成され、実行中タスクがAbortedとなればよい
+            yield (0, informTaskIfNeeded_1.informTaskIfNeeded)({ task, executionEndDate: endDate })(repos);
+            const result = {
+                executedAt: now,
+                endDate,
+                error: Object.assign(Object.assign({}, error), { code: error.code, message: error.message, name: error.name, stack: error.stack })
+            };
+            yield repos.task.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries: task.remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory.taskStatus.Aborted,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+    });
+}

package/lib/chevre/service/taskHandler.d.ts

@@ -0,0 +1,26 @@
+import type { SendGridCredentials } from '../credentials/sendGrid';
+import type { IExecuteSettings as IMinimumExecuteSettings, INextFunction } from '../eventEmitter/task';
+import * as factory from '../factory';
+import type { IExecutableTask, IExecutableTaskKeys } from '../repo/task';
+import type { Settings } from '../settings';
+import type { AggregationSettings } from '../settings/aggregation';
+interface ICredentialSettings {
+    sendGrid: SendGridCredentials;
+}
+interface IExecuteSettings extends IMinimumExecuteSettings {
+    credentials: ICredentialSettings;
+    settings: Settings;
+    aggregationSettings?: AggregationSettings;
+}
+interface IExecuteOptions {
+    executeById: boolean;
+    executeByName: boolean;
+}
+type IOperationExecute<T> = (settings: IExecuteSettings, options: IExecuteOptions) => Promise<T>;
+type ICallResult = void | Pick<factory.task.IExecutionResult, 'error'>;
+type ICallableTaskOperation = (task: IExecutableTask<factory.taskName>) => IOperationExecute<ICallResult>;
+/**
+ * タスクを実行する
+ */
+declare function executeTask(task: IExecutableTask<factory.taskName>, next?: INextFunction): IOperationExecute<void>;
+export { ICallableTaskOperation, ICallResult, IExecutableTaskKeys, IOperationExecute, executeTask };

package/lib/chevre/service/taskHandler.js

@@ -0,0 +1,97 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTask = executeTask;
+const createDebug = require("debug");
+const moment = require("moment");
+const factory = require("../factory");
+const onOperationFailed_1 = require("./taskHandler/onOperationFailed");
+const debug = createDebug('chevre-domain:service:taskHandler');
+/**
+ * タスクを実行する
+ */
+// tslint:disable-next-line:max-func-body-length
+function executeTask(task, next) {
+    const now = new Date();
+    debug('executing an executableTask...', task, now);
+    return (settings, options) => __awaiter(this, void 0, void 0, function* () {
+        const settingRepo = new (yield Promise.resolve().then(() => require('../repo/setting'))).SettingRepo(settings.connection);
+        const taskRepo = new (yield Promise.resolve().then(() => require('../repo/task'))).TaskRepo(settings.connection);
+        try {
+            // 期限検証(2024-04-23~)
+            if (task.expires instanceof Date) {
+                const taskExpired = moment(now)
+                    .isAfter(task.expires);
+                if (taskExpired) {
+                    throw new factory.errors.Internal(`task expired [expires:${task.expires}]`);
+                }
+            }
+            // remainingNumberOfTries<0ならcallを実行しない(2025-08-04~)
+            // リトライを繰り返した後、不明の原因でRunningのまま残ってしまったタスクがリトライされたケース
+            const { remainingNumberOfTries } = task;
+            const isCallable = remainingNumberOfTries >= 0;
+            if (!isCallable) {
+                throw new factory.errors.Internal(`task remainingNumberOfTries < 0 [remainingNumberOfTries:${remainingNumberOfTries}]`);
+            }
+            // タスク名の関数が定義されていなければ、TypeErrorとなる
+            let callResult;
+            const { call } = yield Promise.resolve(`${`./task/${task.name}`}`).then(s => require(s));
+            switch (task.name) {
+                case factory.taskName.AcceptCOAOffer:
+                case factory.taskName.AggregateOnSystem:
+                case factory.taskName.AuthorizePayment:
+                case factory.taskName.CancelPendingReservation:
+                case factory.taskName.CheckMovieTicket:
+                case factory.taskName.DeletePerson:
+                case factory.taskName.HandleNotification:
+                case factory.taskName.ImportEventCapacitiesFromCOA:
+                case factory.taskName.ImportEventsFromCOA:
+                case factory.taskName.ImportOffersFromCOA:
+                case factory.taskName.InvalidatePaymentUrl:
+                case factory.taskName.OnAuthorizationCreated:
+                case factory.taskName.Pay:
+                case factory.taskName.PublishPaymentUrl:
+                case factory.taskName.Refund:
+                case factory.taskName.VoidPayTransaction:
+                case factory.taskName.VoidReserveTransaction:
+                case factory.taskName.ConfirmPayTransaction:
+                case factory.taskName.ConfirmReserveTransaction:
+                case factory.taskName.ReturnPayTransaction:
+                case factory.taskName.ReturnReserveTransaction:
+                case factory.taskName.SendEmailMessage:
+                case factory.taskName.TriggerWebhook:
+                    callResult = yield call(task)(settings, options);
+                    break;
+                default:
+                    yield call(task.data)(settings);
+            }
+            const result = {
+                executedAt: now,
+                endDate: new Date(),
+                // enable overwriting task.executionResults.error on Executed(2024-05-29~)
+                error: ((callResult === null || callResult === void 0 ? void 0 : callResult.error) instanceof Error)
+                    ? Object.assign(Object.assign({}, callResult.error), { message: callResult.error.message }) : ''
+            };
+            yield taskRepo.setExecutionResultAndStatus({
+                id: task.id,
+                remainingNumberOfTries,
+                name: task.name
+            }, {
+                status: factory.taskStatus.Executed,
+                executionResult: result
+            }, (typeof next === 'function') ? next : undefined);
+        }
+        catch (error) {
+            debug('service.task.execute throwed an error. task:', task.name, task.id, 'error:', error === null || error === void 0 ? void 0 : error.name, error === null || error === void 0 ? void 0 : error.message);
+            yield (0, onOperationFailed_1.onOperationFailed)(Object.assign({ task, now, error }, (typeof next === 'function') ? { next } : undefined))({ setting: settingRepo, task: taskRepo });
+        }
+    });
+}

package/lib/chevre/service/validation/validateEvent.d.ts

@@ -1,11 +1,11 @@
 import type { EventRepo } from '../../repo/event';
 import type { StockHolderRepo } from '../../repo/stockHolder';
-export declare function validateEvent(params: {
+export declare function validateEvent(__: {
     id: string;
     project: {
         id: string;
     };
-}): (repos: {
+}): (__2: {
     event: EventRepo;
     stockHolder: StockHolderRepo;
 }) => Promise<void>;

package/lib/chevre/service/validation/validateEvent.js

@@ -1,4 +1,5 @@
 "use strict";
+// import * as createDebug from 'debug';
 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) {
@@ -10,15 +11,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEvent = validateEvent;
-const createDebug = require("debug");
-const debug = createDebug('chevre-domain:service:validation');
-function validateEvent(params) {
-    return (repos) => __awaiter(this, void 0, void 0, function* () {
-        const event = yield repos.event.projectEventFieldsById({ id: params.id }, ['startDate']);
-        debug('validateEvent: conflicted?', params.project.id, event.id, event.startDate);
-        yield repos.stockHolder.checkIfConflicted({
-            eventId: event.id,
-            startDate: event.startDate
-        });
+// import * as factory from '../../factory';
+// const debug = createDebug('chevre-domain:service:validation');
+function validateEvent(__) {
+    return (__2) => __awaiter(this, void 0, void 0, function* () {
+        // const event: Pick<factory.event.screeningEvent.IEvent, 'id' | 'startDate'> =
+        //     await repos.event.projectEventFieldsById<factory.eventType.ScreeningEvent>(
+        //         { id: params.id },
+        //         ['startDate']
+        //     );
+        // discontinue redis(2025-08-17~)
+        // debug('validateEvent: conflicted?', params.project.id, event.id, event.startDate);
+        // await repos.stockHolder.checkIfConflicted({
+        //     eventId: event.id,
+        //     startDate: event.startDate
+        // });
     });
 }

package/lib/chevre/service.d.ts

@@ -11,7 +11,6 @@ import type * as AccountService from './service/account';
 import type * as AccountTransactionService from './service/accountTransaction';
 import type * as AggregationService from './service/aggregation';
 import type * as AssetTransactionService from './service/assetTransaction';
-import type * as CodeService from './service/code';
 import type * as DeliveryService from './service/delivery';
 import type * as EventService from './service/event';
 import type * as IAMService from './service/iam';
@@ -37,9 +36,6 @@ export declare namespace aggregation {
 export declare namespace assetTransaction {
     function createService(): Promise<typeof AssetTransactionService>;
 }
-export declare namespace code {
-    function createService(): Promise<typeof CodeService>;
-}
 export declare namespace delivery {
     function createService(): Promise<typeof DeliveryService>;
 }

package/lib/chevre/service.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.factory = exports.transaction = exports.task = exports.reserve = exports.report = exports.project = exports.permit = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.delivery = exports.code = exports.assetTransaction = exports.aggregation = exports.accountTransaction = exports.account = void 0;
+exports.factory = exports.transaction = exports.task = exports.reserve = exports.report = exports.project = exports.permit = exports.payment = exports.order = exports.offer = exports.notification = exports.iam = exports.event = exports.delivery = exports.assetTransaction = exports.aggregation = exports.accountTransaction = exports.account = void 0;
 /**
  * service module
  */
@@ -72,19 +72,15 @@ var assetTransaction;
     }
     assetTransaction.createService = createService;
 })(assetTransaction || (exports.assetTransaction = assetTransaction = {}));
-var code;
-(function (code) {
-    let service;
-    function createService() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (service === undefined) {
-                service = yield Promise.resolve().then(() => require('./service/code'));
-            }
-            return service;
-        });
-    }
-    code.createService = createService;
-})(code || (exports.code = code = {}));
+// export namespace code {
+//     let service: typeof CodeService | undefined;
+//     export async function createService() {
+//         if (service === undefined) {
+//             service = await import('./service/code');
+//         }
+//         return service;
+//     }
+// }
 var delivery;
 (function (delivery) {
     let service;

package/lib/chevre/settings/aggregation.d.ts

@@ -1,11 +1,14 @@
 import * as factory from '../factory';
-import type { ICallableTaskOperation, ICallResult, IOperationExecute } from '../service/task';
+import type { ICallableTaskOperation, ICallResult, IOperationExecute } from '../service/taskHandler';
 interface IOnOrderStatusChanged {
     informOrder2hub?: factory.project.IInformParams[];
 }
 interface IOnReservationStatusChanged {
     informReservation2hub?: factory.project.IInformParams[];
 }
+interface IOnTaskStatusChanged {
+    informTask2hub?: factory.project.IInformParams[];
+}
 interface ICallableTask {
     aggregateOnSystem?: ICallableTaskOperation;
     handleNotification?: ICallableTaskOperation;
@@ -17,6 +20,7 @@ interface IOptions {
     callableTask?: ICallableTask;
     onOrderStatusChanged: IOnOrderStatusChanged;
     onReservationStatusChanged: IOnReservationStatusChanged;
+    onTaskStatusChanged: IOnTaskStatusChanged;
 }
 /**
  * aggregation domain settings
@@ -25,6 +29,7 @@ declare class AggregationSettings {
     readonly callableTask?: ICallableTask;
     readonly onOrderStatusChanged: IOnOrderStatusChanged;
     readonly onReservationStatusChanged: IOnReservationStatusChanged;
+    readonly onTaskStatusChanged: IOnTaskStatusChanged;
     constructor(options: IOptions);
 }
 export { ICallableTaskOperation, ICallResult, IOperationExecute, AggregationSettings };

package/lib/chevre/settings/aggregation.js

@@ -6,9 +6,10 @@ exports.AggregationSettings = void 0;
  */
 class AggregationSettings {
     constructor(options) {
-        const { callableTask, onOrderStatusChanged, onReservationStatusChanged } = options;
+        const { callableTask, onOrderStatusChanged, onReservationStatusChanged, onTaskStatusChanged } = options;
         this.onOrderStatusChanged = onOrderStatusChanged;
         this.onReservationStatusChanged = onReservationStatusChanged;
+        this.onTaskStatusChanged = onTaskStatusChanged;
         if (callableTask !== undefined) {
             this.callableTask = callableTask;
         }

package/package.json

@@ -11,10 +11,10 @@
   "dependencies": {
     "@aws-sdk/client-cognito-identity-provider": "3.600.0",
     "@aws-sdk/credential-providers": "3.600.0",
-    "@chevre/factory": "4.395.0-alpha.3",
-    "@cinerino/sdk": "11.0.0-alpha.4",
+    "@chevre/factory": "4.396.0",
+    "@cinerino/sdk": "12.0.0-alpha.0",
     "@motionpicture/coa-service": "9.6.0",
-    "@motionpicture/gmo-service": "5.3.0",
+    "@motionpicture/gmo-service": "5.4.0-alpha.0",
     "@sendgrid/client": "8.1.4",
     "@surfrock/sdk": "1.4.0-alpha.1",
     "cdigit": "2.6.7",
@@ -49,10 +49,12 @@
     "@types/sinon-mongoose": "^1.3.11",
     "@types/uniqid": "^4.1.3",
     "@types/uuid": "^3.4.10",
+    "auth0": "4.27.0",
     "coveralls": "^3.1.0",
     "csvtojson": "^2.0.10",
     "eslint": "9.16.0",
     "googleapis": "^85.0.0",
+    "jose": "6.0.12",
     "json2csv": "4.5.4",
     "mocha": "10.6.0",
     "mongoose": "8.0.4",
@@ -113,5 +115,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "22.11.0-alpha.8"
+  "version": "22.11.0"
 }

package/example/src/chevre/adminAuth/adminIdentity.ts

@@ -1,38 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-const ADMIN_AUTH_ENDPOINT = process.env.ADMIN_AUTH_ENDPOINT;
-
-async function main() {
-    if (typeof ADMIN_AUTH_ENDPOINT !== 'string') {
-        throw new Error('ADMIN_AUTH_ENDPOINT undfined');
-    }
-
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const adminIdentityService = await (await (await chevre.loadAdminAuth()).loadChevreAuth({
-        endpoint: ADMIN_AUTH_ENDPOINT
-    })).createIdentityInstance();
-
-    const identities = await adminIdentityService.projectIdentityFields(
-        {
-            about: { id: { $eq: '36jneiog293vb2c7u9e5p4rn7r' } }
-            // identifier: { $eq: IDENTIFIER }
-        }
-    );
-    console.log('docs:', identities);
-    console.log(identities.length, 'docs found');
-
-    const { id } = await adminIdentityService.createIdentity({
-        clientId: 'xxx',
-        clientSecret: 'xxx',
-        iss: ['xxx']
-    });
-    console.log('saved.', id);
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/executeOneTask.ts

@@ -1,41 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment';
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../lib/index';
-
-// const project = { id: String(process.env.PROJECT_ID) };
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
-    const task = await taskRepo.executeOneIfExists({
-        name: {
-            $nin: [
-                chevre.factory.taskName.DeleteTransaction,
-                chevre.factory.taskName.ImportEventCapacitiesFromCOA,
-                chevre.factory.taskName.ImportEventsFromCOA,
-                chevre.factory.taskName.AcceptCOAOffer,
-                chevre.factory.taskName.CheckMovieTicket,
-                chevre.factory.taskName.AuthorizePayment,
-                chevre.factory.taskName.PublishPaymentUrl
-            ]
-        },
-        executor: { name: 'sample' },
-        runsAt: {
-            $lt: moment()
-                // tslint:disable-next-line:no-magic-numbers
-                .add(-2, 'years')
-                // .add(-60, 'seconds')
-                .toDate()
-        }
-    });
-
-    // tslint:disable-next-line:no-null-keyword
-    console.dir(task, { depth: null });
-}
-
-main()
-    .then()
-    .catch(console.error);