@chevre/domain 22.10.0-alpha.9 → 22.11.0-alpha.0

package/example/src/chevre/transactionNumber/setUseMongo4transactionNumberFrom.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+import { chevre } from '../../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+
+const redisClient = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    socket: {
+        port: Number(<string>process.env.REDIS_PORT),
+        host: <string>process.env.REDIS_HOST
+    },
+    password: <string>process.env.REDIS_KEY,
+    name: 'checkRedisKeyCount'
+})
+    .on('error', (err) => {
+        // eslint-disable-next-line no-console
+        console.error('createDefaultRedisClient: client onError:', err);
+        // reject(err);
+    });
+redisClient.connect();
+mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+async function main() {
+    const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
+        redisClient,
+        connection: mongoose.connection
+    });
+    const result = await transactionNumberRepo.setUseMongo4transactionNumberFrom({
+        useMongo4transactionNumberFrom: moment('2025-06-05T22:45:00Z')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/redisMulti.ts

@@ -0,0 +1,63 @@
+
+// tslint:disable:no-console no-magic-numbers no-null-keyword
+import type * as Redis from 'redis';
+
+const REDIS_PING_INTERVAL_MS: number = (typeof process.env.REDIS_PING_INTERVAL_MS === 'string')
+    ? Number(process.env.REDIS_PING_INTERVAL_MS)
+    // tslint:disable-next-line:no-magic-numbers
+    : 30000;
+const REDIS_HOST: string = String(process.env.REDIS_HOST);
+const REDIS_PORT: number = Number(process.env.REDIS_PORT);
+const REDIS_KEY: string = String(process.env.REDIS_KEY);
+
+const redisClientOptions: Redis.RedisClientOptions<Redis.RedisDefaultModules, Record<string, never>, Record<string, never>> = {
+    socket: {
+        host: REDIS_HOST,
+        port: REDIS_PORT
+        // tls: (process.env.REDIS_TLS_SERVERNAME !== undefined) ? { servername: process.env.REDIS_TLS_SERVERNAME } : undefined
+    },
+    password: REDIS_KEY,
+    pingInterval: REDIS_PING_INTERVAL_MS,
+    disableOfflineQueue: false
+};
+
+let redis: typeof Redis | undefined;
+async function createRedisClient(): Promise<Redis.RedisClientType> {
+    return new Promise<Redis.RedisClientType>(async (resolve, reject) => {
+        if (redis === undefined) {
+            redis = await import('redis');
+        }
+
+        const client = redis.createClient<Redis.RedisDefaultModules, Record<string, never>, Record<string, never>>(redisClientOptions)
+            .on('error', (err) => {
+                // tslint:disable-next-line:no-console
+                console.error('createRedisClient: client onError:', err);
+                reject(err);
+            })
+            .on('connect', () => {
+                resolve(client);
+            });
+        // client.on('ready', () => {
+        //     console.error('Redis Client ready');
+        // });
+
+        await client.connect()
+            .catch((err) => {
+                // tslint:disable-next-line:no-console
+                console.error('createRedisClient: redisClient.connect:', err);
+                reject(new Error('createRedisClient: failed in creating connection'));
+            });
+    });
+}
+
+async function main() {
+    const redisClient = await createRedisClient();
+    console.log('redisClient created.', redisClient.options?.name);
+
+    const multi = await redisClient.multi();
+    const results = await multi.exec();
+    console.log(results);
+}
+
+main()
+    .catch(console.error);

package/example/src/signPayload.ts

@@ -5,7 +5,7 @@ async function main(): Promise<void> {
     const payload = {
         member: {
             memberOf: {
-                identifier: 'DefaultTier',
+                identifier: 'bronze',
                 isTierOf: {
                     identifier: 'DefaultMemberProgram'
                 }

package/lib/chevre/adminAuth.d.ts

@@ -0,0 +1,2 @@
+import { auth, chevreAuth, loadChevreAuth } from '@cinerino/sdk';
+export { auth, loadChevreAuth, chevreAuth };

package/lib/chevre/adminAuth.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadChevreAuth = exports.auth = void 0;
+const sdk_1 = require("@cinerino/sdk");
+Object.defineProperty(exports, "auth", { enumerable: true, get: function () { return sdk_1.auth; } });
+Object.defineProperty(exports, "loadChevreAuth", { enumerable: true, get: function () { return sdk_1.loadChevreAuth; } });

package/lib/chevre/eventEmitter/task.d.ts

@@ -1,18 +1,48 @@
 import { EventEmitter } from 'events';
+import type { Connection } from 'mongoose';
+import type { RedisClientType } from 'redis';
 import * as factory from '../factory';
-interface IListenArgsOnTaskStatusChanged {
+interface IExecuteSettings {
+    /**
+     * MongoDBコネクション
+     */
+    connection: Connection;
+    /**
+     * Redisクライアント
+     */
+    redisClient?: RedisClientType;
+}
+type IOperationExecute<T> = (settings: IExecuteSettings) => Promise<T>;
+type INextFunction = (task: Pick<factory.task.ITask<factory.taskName>, 'id'>) => IOperationExecute<void>;
+interface IReadyTask {
     id: string;
     name?: factory.taskName;
-    status: factory.taskStatus.Ready | factory.taskStatus.Running;
+    status: factory.taskStatus.Ready;
     expires?: Date;
+    executionResult?: never;
+}
+interface IRunningTask {
+    id: string;
+    status: factory.taskStatus.Running;
+    name?: never;
+    expires?: never;
+    executionResult?: never;
+}
+interface IExecutedTask {
+    id: string;
+    status: factory.taskStatus;
+    executionResult: factory.task.IExecutionResult;
+    name?: never;
+    expires?: never;
 }
-type IOnTaskStatusChangedListener = (listenArgs: IListenArgsOnTaskStatusChanged) => void;
+type IChangedTask = IReadyTask | IRunningTask | IExecutedTask;
+type IOnTaskStatusChangedListener = (task: IChangedTask, next?: INextFunction) => void;
 /**
  * タスクイベントエミッター
  */
 declare class TaskEventEmitter extends EventEmitter {
-    onTaskStatusChanged(listner: IOnTaskStatusChangedListener): void;
-    emitTaskStatusChanged(args: IListenArgsOnTaskStatusChanged): void;
+    onTaskStatusChanged(listener: IOnTaskStatusChangedListener): void;
+    emitTaskStatusChanged(task: IChangedTask, next?: INextFunction): void;
 }
 declare const taskEventEmitter: TaskEventEmitter;
-export { IOnTaskStatusChangedListener, taskEventEmitter };
+export { IChangedTask, IReadyTask, IRunningTask, IExecutedTask, IExecuteSettings, INextFunction, IOnTaskStatusChangedListener, taskEventEmitter };

package/lib/chevre/eventEmitter/task.js

@@ -10,11 +10,12 @@ var EventName;
  * タスクイベントエミッター
  */
 class TaskEventEmitter extends events_1.EventEmitter {
-    onTaskStatusChanged(listner) {
-        this.on(EventName.OnTaskStatusChanged, listner);
+    onTaskStatusChanged(listener) {
+        this.on(EventName.OnTaskStatusChanged, listener);
     }
-    emitTaskStatusChanged(args) {
-        this.emit(EventName.OnTaskStatusChanged, args);
+    // support next function required(2025-05-25~)
+    emitTaskStatusChanged(task, next) {
+        this.emit(EventName.OnTaskStatusChanged, task, (typeof next === 'function') ? next : undefined);
     }
 }
 const taskEventEmitter = new TaskEventEmitter();

package/lib/chevre/eventEmitter.d.ts

@@ -1,4 +1,4 @@
 import { assetTransactionEventEmitter } from './eventEmitter/assetTransaction';
-import { taskEventEmitter } from './eventEmitter/task';
+import * as task from './eventEmitter/task';
 import { transactionEventEmitter } from './eventEmitter/transaction';
-export { assetTransactionEventEmitter as assetTransaction, taskEventEmitter as task, transactionEventEmitter as transaction };
+export { assetTransactionEventEmitter as assetTransaction, task, transactionEventEmitter as transaction };

package/lib/chevre/eventEmitter.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transaction = exports.task = exports.assetTransaction = void 0;
 const assetTransaction_1 = require("./eventEmitter/assetTransaction");
 Object.defineProperty(exports, "assetTransaction", { enumerable: true, get: function () { return assetTransaction_1.assetTransactionEventEmitter; } });
-const task_1 = require("./eventEmitter/task");
-Object.defineProperty(exports, "task", { enumerable: true, get: function () { return task_1.taskEventEmitter; } });
+const task = require("./eventEmitter/task");
+exports.task = task;
 const transaction_1 = require("./eventEmitter/transaction");
 Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return transaction_1.transactionEventEmitter; } });

package/lib/chevre/index.d.ts

@@ -3,6 +3,7 @@
  */
 import type * as COAService from '@motionpicture/coa-service';
 import type * as GMOService from '@motionpicture/gmo-service';
+import type * as AdminAuth from './adminAuth';
 import type * as Pecorinoapi from './pecorinoapi';
 import { credentials } from './credentials';
 import * as errorHandler from './errorHandler';
@@ -12,6 +13,7 @@ import * as repository from './repository';
 import * as service from './service';
 import * as settings from './settings';
 export { credentials, errorHandler, eventEmitter, factory, repository, service, settings };
+export declare function loadAdminAuth(): Promise<typeof AdminAuth>;
 export declare function loadPecorinoapi(): Promise<typeof Pecorinoapi>;
 export type COA = typeof COAService;
 export declare function loadCOA(): Promise<typeof COAService>;

package/lib/chevre/index.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.settings = exports.service = exports.repository = exports.factory = exports.eventEmitter = exports.errorHandler = exports.credentials = void 0;
+exports.loadAdminAuth = loadAdminAuth;
 exports.loadPecorinoapi = loadPecorinoapi;
 exports.loadCOA = loadCOA;
 exports.loadGMO = loadGMO;
@@ -27,6 +28,15 @@ const service = require("./service");
 exports.service = service;
 const settings = require("./settings");
 exports.settings = settings;
+let adminAuth;
+function loadAdminAuth() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (adminAuth === undefined) {
+            adminAuth = yield Promise.resolve().then(() => require('./adminAuth'));
+        }
+        return adminAuth;
+    });
+}
 let pecorinoapi;
 function loadPecorinoapi() {
     return __awaiter(this, void 0, void 0, function* () {

package/lib/chevre/repo/concurrentLock.d.ts

@@ -0,0 +1,14 @@
+import type { RedisClientType } from 'redis';
+import { AbstractConcurrentLockRepo, ILockParams, IUnlockParams } from './concurrentLockAbstract';
+/**
+ * 同時実行ロックリポジトリ
+ */
+export declare class ConcurrentLockRepo implements AbstractConcurrentLockRepo {
+    private readonly redisClient;
+    constructor(params: {
+        redisClient: RedisClientType;
+    });
+    static CREATE_REDIS_KEY(params: Pick<ILockParams, 'about'>): string;
+    lock(params: ILockParams): Promise<void>;
+    unlock(params: IUnlockParams): Promise<void>;
+}

package/lib/chevre/repo/concurrentLock.js

@@ -0,0 +1,48 @@
+"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.ConcurrentLockRepo = void 0;
+const factory = require("../factory");
+/**
+ * 同時実行ロックリポジトリ
+ */
+class ConcurrentLockRepo {
+    constructor(params) {
+        const { redisClient } = params;
+        this.redisClient = redisClient;
+    }
+    static CREATE_REDIS_KEY(params) {
+        return params.about.identifier;
+    }
+    lock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = ConcurrentLockRepo.CREATE_REDIS_KEY(params);
+            const value = params.audience.identifier;
+            const results = yield this.redisClient.multi()
+                .setNX(key, value)
+                .expireAt(key, params.expires)
+                .exec();
+            if (Array.isArray(results) && (results[0] === 1 || results[0] === true)) {
+                return;
+            }
+            else {
+                throw new factory.errors.AlreadyInUse(params.about.identifier, []);
+            }
+        });
+    }
+    unlock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = ConcurrentLockRepo.CREATE_REDIS_KEY(params);
+            yield this.redisClient.del([key]);
+        });
+    }
+}
+exports.ConcurrentLockRepo = ConcurrentLockRepo;

package/lib/chevre/repo/concurrentLockAbstract.d.ts

@@ -0,0 +1,42 @@
+import * as factory from '../factory';
+export interface IOffer {
+    itemOffered?: {
+        serviceOutput?: {
+            /**
+             * 予約ID
+             */
+            id?: string;
+        };
+    };
+    seatSection: string;
+    seatNumber: string;
+}
+export interface IAbout {
+    identifier: string;
+    typeOf: 'Thing';
+}
+export interface IAudience {
+    identifier: string;
+    typeOf: 'Audience';
+}
+export interface IConcurrentLock {
+    project: {
+        id: string;
+        typeOf: factory.organizationType.Project;
+    };
+    typeOf: factory.creativeWorkType.Certification;
+    about: IAbout;
+    dateCreated: Date;
+    expires: Date;
+    audience: IAudience;
+}
+export type ILockParams = Pick<IConcurrentLock, 'about' | 'audience' | 'expires' | 'project'>;
+export type IUnlockParams = Pick<IConcurrentLock, 'about' | 'audience'>;
+export type IGetHolderResult = string | null;
+/**
+ * 抽象同時実行ロックリポジトリ
+ */
+export declare abstract class AbstractConcurrentLockRepo {
+    abstract lock(lockKey: ILockParams): Promise<void>;
+    abstract unlock(params: IUnlockParams): Promise<void>;
+}

package/lib/chevre/repo/concurrentLockAbstract.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractConcurrentLockRepo = void 0;
+/**
+ * 抽象同時実行ロックリポジトリ
+ */
+class AbstractConcurrentLockRepo {
+}
+exports.AbstractConcurrentLockRepo = AbstractConcurrentLockRepo;

package/lib/chevre/repo/confirmationNumber.d.ts

@@ -1,17 +1,30 @@
+import type { Connection } from 'mongoose';
 import { RedisClientType } from 'redis';
+import { ISetting } from './mongoose/schemas/setting';
 /**
  * 確認番号リポジトリ
  */
 export declare class ConfirmationNumberRepo {
-    private static readonly REDIS_KEY_PREFIX_NEW;
-    private readonly redisClient;
-    constructor(redisClient: RedisClientType);
+    private readonly settingModel;
+    private readonly counterRepo;
+    constructor(params: {
+        redisClient: RedisClientType;
+        connection: Connection;
+    });
     private static alignDigits;
-    private static createKey;
+    private static createDataFeedIdentifier;
+    private static count2confirmationNumber;
     /**
      * 発行する
      */
     publish(params: {
         orderDate: Date;
     }): Promise<string>;
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4confirmationNumberFrom(params: {
+        useMongo4confirmationNumberFrom: Date;
+    }): Promise<Pick<ISetting, "useMongo4confirmationNumberFrom"> | null>;
+    private useMongoBySettings;
 }

package/lib/chevre/repo/confirmationNumber.js

@@ -12,17 +12,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfirmationNumberRepo = void 0;
 const cdigit = require("cdigit");
 const moment = require("moment-timezone");
-const util = require("util");
 // tslint:disable-next-line:no-require-imports no-var-requires
 const fpe = require('node-fpe');
-const factory = require("../factory");
+const setting_1 = require("./mongoose/schemas/setting");
+const transactionNumber_1 = require("./mongoose/schemas/transactionNumber");
+const transactionNumberCounter_1 = require("./transactionNumberCounter");
 const CONFIRMATION_NUMBER_MIN_LENGH = 4;
+const TIMEZONE = 'Asia/Tokyo';
 /**
  * 確認番号リポジトリ
  */
 class ConfirmationNumberRepo {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
+    constructor(params) {
+        const { connection } = params;
+        this.settingModel = connection.model(setting_1.modelName, (0, setting_1.createSchema)());
+        this.counterRepo = new transactionNumberCounter_1.TransactionNumberCounterRepo(params);
     }
     static alignDigits(params) {
         let aligndNumber = String(params);
@@ -32,42 +36,95 @@ class ConfirmationNumberRepo {
         }
         return aligndNumber;
     }
-    static createKey(params) {
-        return util.format('%s:%s', ConfirmationNumberRepo.REDIS_KEY_PREFIX_NEW, moment(params.orderDate)
-            .tz('Asia/Tokyo')
-            .format('YYMM'));
+    // private static createKey(params: {
+    //     orderDate: Date;
+    // }): string {
+    //     return util.format(
+    //         '%s:%s',
+    //         ConfirmationNumberRepo.REDIS_KEY_PREFIX_NEW,
+    //         moment(params.orderDate)
+    //             .tz(TIMEZONE)
+    //             .format('YYMM')
+    //     );
+    // }
+    static createDataFeedIdentifier(params) {
+        return moment(params.orderDate)
+            .tz(TIMEZONE)
+            .format('YYMM');
+    }
+    static count2confirmationNumber(params) {
+        // 桁数調整
+        let confirmationNumber = ConfirmationNumberRepo.alignDigits(params.count);
+        // checkdigit
+        const cd = cdigit.luhn.compute(confirmationNumber);
+        // debug('check digit:', cd);
+        confirmationNumber = fpe({ password: cd })
+            .encrypt(confirmationNumber);
+        confirmationNumber = `${cd}${confirmationNumber}`;
+        return confirmationNumber;
     }
     /**
      * 発行する
      */
     publish(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // データ保管期間はとりあえず一か月
-            const TTL = moment(params.orderDate)
-                .add(1, 'month')
-                .diff(moment(params.orderDate), 'seconds');
-            const key = ConfirmationNumberRepo.createKey({ orderDate: params.orderDate });
-            const [incrReply] = yield this.redisClient.multi()
-                .incr(key)
-                .expire(key, TTL)
-                .exec();
-            // tslint:disable-next-line:no-single-line-block-comment
-            /* istanbul ignore if */
-            if (typeof incrReply !== 'number') {
-                // 基本的にありえないフロー
-                throw new factory.errors.Internal('confirmation number not incremented unexpectedly');
+            let dataFeedExpires;
+            const dataFeedIdentifier = ConfirmationNumberRepo.createDataFeedIdentifier({ orderDate: params.orderDate });
+            let incrReply;
+            // support publishByMongo(2025-05-23~)
+            const useMongoBySettings = yield this.useMongoBySettings(params);
+            if (useMongoBySettings) {
+                // データ保管期間はとりあえず2 months
+                dataFeedExpires = moment(params.orderDate)
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(2, 'months')
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByMongo({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.confirmationNumber },
+                    expires: dataFeedExpires
+                });
             }
-            // 桁数調整
-            let confirmationNumber = ConfirmationNumberRepo.alignDigits(incrReply);
-            // checkdigit
-            const cd = cdigit.luhn.compute(confirmationNumber);
-            // debug('check digit:', cd);
-            confirmationNumber = fpe({ password: cd })
-                .encrypt(confirmationNumber);
-            confirmationNumber = `${cd}${confirmationNumber}`;
-            return confirmationNumber;
+            else {
+                // データ保管期間はとりあえず一か月
+                dataFeedExpires = moment(params.orderDate)
+                    .add(1, 'month')
+                    .toDate();
+                incrReply = yield this.counterRepo.incrementByRedis({
+                    identifier: dataFeedIdentifier,
+                    includedInDataCatalog: { identifier: transactionNumber_1.DataCatalogIdentifier.confirmationNumber },
+                    expires: dataFeedExpires
+                });
+            }
+            return ConfirmationNumberRepo.count2confirmationNumber({ count: incrReply });
+        });
+    }
+    /**
+     * DB移行時のみに使用目的の設定更新
+     */
+    setUseMongo4confirmationNumberFrom(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { useMongo4confirmationNumberFrom } = params;
+            return this.settingModel.findOneAndUpdate({ 'project.id': { $eq: '*' } }, {
+                $set: { useMongo4confirmationNumberFrom }
+            }, { projection: { _id: 0, useMongo4confirmationNumberFrom: 1 } })
+                .lean()
+                .exec();
+        });
+    }
+    useMongoBySettings(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const setting = yield this.settingModel.findOne({ 'project.id': { $eq: '*' } }, {
+                _id: 0,
+                useMongo4confirmationNumberFrom: 1
+            })
+                .lean()
+                .exec();
+            const useMongo4confirmationNumberFrom = setting === null || setting === void 0 ? void 0 : setting.useMongo4confirmationNumberFrom;
+            return useMongo4confirmationNumberFrom instanceof Date
+                && moment(params.orderDate)
+                    .isSameOrAfter(moment(useMongo4confirmationNumberFrom));
         });
     }
 }
 exports.ConfirmationNumberRepo = ConfirmationNumberRepo;
-ConfirmationNumberRepo.REDIS_KEY_PREFIX_NEW = 'confirmationNumber';

package/lib/chevre/repo/identity.d.ts

@@ -1,9 +1,10 @@
-import { Connection, FilterQuery } from 'mongoose';
+import { Connection, FilterQuery, QueryOptions } from 'mongoose';
 import * as factory from '../factory';
-export type ISavingIdentity = Pick<factory.creativeWork.certification.webApplication.ICertification, 'about' | 'issuedBy' | 'project' | 'typeOf'> & {
+export type ISavingIdentity = Pick<factory.creativeWork.certification.webApplication.ICertification, 'about' | 'project' | 'typeOf'> & {
     id?: never;
     dateCreated?: never;
     dateModified?: never;
+    issuedBy: factory.creativeWork.certification.webApplication.IIssuedBy[];
 };
 interface IUnset {
     $unset?: {
@@ -21,18 +22,54 @@ export declare class IdentityRepo {
     private readonly identityModel;
     constructor(connection: Connection);
     static CREATE_FILTER_QUERY(params: factory.creativeWork.certification.webApplication.ISearchConditions): FilterQuery<factory.creativeWork.certification.webApplication.ICertification>[];
-    save(params: {
+    saveIdentity(params: {
         id?: string;
         attributes: ISavingIdentity & IUnset;
     }): Promise<{
         id: string;
     }>;
-    projectFields(conditions: factory.creativeWork.certification.webApplication.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IIdentityWithId[]>;
-    deleteById(params: {
+    projectIdentityFields(conditions: factory.creativeWork.certification.webApplication.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<IIdentityWithId[]>;
+    deleteIdentityById(params: {
         id: string;
         project: {
             id: string;
         };
     }): Promise<void>;
+    getCursor(conditions: any, projection: any): import("mongoose").Cursor<import("mongoose").Document<unknown, {}, {
+        project: Pick<factory.project.IProject, "id" | "typeOf">;
+        typeOf: factory.creativeWorkType.Certification;
+        about: import("@chevre/factory/lib/creativeWork/certification/webApplication").IAbout;
+        dateCreated?: Date | undefined;
+        dateModified?: Date | undefined;
+        issuedBy: import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy | import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy[];
+    }> & {
+        project: Pick<factory.project.IProject, "id" | "typeOf">;
+        typeOf: factory.creativeWorkType.Certification;
+        about: import("@chevre/factory/lib/creativeWork/certification/webApplication").IAbout;
+        dateCreated?: Date | undefined;
+        dateModified?: Date | undefined;
+        issuedBy: import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy | import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy[];
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    }, QueryOptions<import("mongoose").Document<unknown, {}, {
+        project: Pick<factory.project.IProject, "id" | "typeOf">;
+        typeOf: factory.creativeWorkType.Certification;
+        about: import("@chevre/factory/lib/creativeWork/certification/webApplication").IAbout;
+        dateCreated?: Date | undefined;
+        dateModified?: Date | undefined;
+        issuedBy: import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy | import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy[];
+    }> & {
+        project: Pick<factory.project.IProject, "id" | "typeOf">;
+        typeOf: factory.creativeWorkType.Certification;
+        about: import("@chevre/factory/lib/creativeWork/certification/webApplication").IAbout;
+        dateCreated?: Date | undefined;
+        dateModified?: Date | undefined;
+        issuedBy: import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy | import("@chevre/factory/lib/creativeWork/certification/webApplication").IIssuedBy[];
+    } & {
+        _id: import("mongoose").Types.ObjectId;
+    }>>;
+    updateIssuedBy2array(params: Pick<ISavingIdentity, 'issuedBy'> & {
+        id: string;
+    }): Promise<void>;
 }
 export {};