@chevre/domain 23.0.0-alpha.8 → 23.0.0

package/example/src/chevre/product/findHasOfferCatalog.ts

@@ -0,0 +1,31 @@
+// tslint:disable:no-console
+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, { autoIndex: false });
+
+    const productHasOfferCatalogRepo = await chevre.repository.ProductHasOfferCatalog.createInstance(mongoose.connection);
+
+    try {
+        const offerCatalogs = (await productHasOfferCatalogRepo.findOfferCatalogs(
+            {
+                limit: 10,
+                page: 1,
+                project: { id: { $eq: project.id } },
+                product: { id: { $in: ['656038908b1cd5ce629f5992', '60c1c0031fb182000bed5eff'] } }
+            }
+        ));
+        // tslint:disable-next-line:no-null-keyword
+        console.dir(offerCatalogs, { depth: null });
+    } catch (error) {
+        throw await chevre.errorHandler.handleMongoError(error);
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/reIndex.ts

@@ -11,9 +11,8 @@ mongoose.Model.on('index', (...args) => {
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection);
-    await chevre.repository.Seller.createInstance(mongoose.connection);
-    await chevre.repository.ProductOffer.createInstance(mongoose.connection);
+    await chevre.repository.CategoryCode.createInstance(mongoose.connection);
+    // await chevre.repository.MovieTicketType.createInstance(mongoose.connection);
     console.log('success!');
 }
 

package/example/src/chevre/roles/addAdminNotePermissionIfNotExists.ts

@@ -0,0 +1,48 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+        // chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        // chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
+    ];
+    const permissions = [
+        'admin.notes.*'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    // roleNames = [
+    //     chevre.factory.role.organizationRole.RoleName.TicketClerk
+    // ];
+    // permissions = [
+    //     'admin.sellers.productOffers.read'
+    // ];
+    // for (const roleName of roleNames) {
+    //     for (const permission of permissions) {
+    //         const result = await roleRepo.addPermissionIfNotExists({
+    //             roleName: { $eq: roleName },
+    //             permission
+    //         });
+    //         console.log('permission added.', result, roleName);
+    //     }
+    // }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/{addAdminProductOfferPermissionIfNotExists.ts → addAdminPaymentServiceReadPermissionIfNotExists.ts}

@@ -8,29 +8,14 @@ async function main() {
 
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
-    let roleNames = [
+    const roleNames = [
         chevre.factory.role.organizationRole.RoleName.InventoryManager,
         chevre.factory.role.organizationRole.RoleName.SellersOwner,
-        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
-    ];
-    let permissions = [
-        'admin.sellers.productOffers.*'
-    ];
-    for (const roleName of roleNames) {
-        for (const permission of permissions) {
-            const result = await roleRepo.addPermissionIfNotExists({
-                roleName: { $eq: roleName },
-                permission
-            });
-            console.log('permission added.', result, roleName);
-        }
-    }
-
-    roleNames = [
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
         chevre.factory.role.organizationRole.RoleName.TicketClerk
     ];
-    permissions = [
-        'admin.sellers.productOffers.read'
+    const permissions = [
+        'admin.paymentServices.read'
     ];
     for (const roleName of roleNames) {
         for (const permission of permissions) {
@@ -41,6 +26,22 @@ async function main() {
             console.log('permission added.', result, roleName);
         }
     }
+
+    // roleNames = [
+    //     chevre.factory.role.organizationRole.RoleName.TicketClerk
+    // ];
+    // permissions = [
+    //     'admin.sellers.productOffers.read'
+    // ];
+    // for (const roleName of roleNames) {
+    //     for (const permission of permissions) {
+    //         const result = await roleRepo.addPermissionIfNotExists({
+    //             roleName: { $eq: roleName },
+    //             permission
+    //         });
+    //         console.log('permission added.', result, roleName);
+    //     }
+    // }
 }
 
 main()

package/example/src/chevre/roles/addAdminProductHasOfferCatalogReadPermissionIfNotExists.ts

@@ -0,0 +1,33 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager
+        // chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        // chevre.factory.role.organizationRole.RoleName.SellersInventoryManager,
+        // chevre.factory.role.organizationRole.RoleName.TicketClerk
+    ];
+    const permissions = [
+        'admin.productHasOfferCatalog.read'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/addAdminSellerEventIfNotExists.ts

@@ -0,0 +1,48 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
+
+    const roleNames = [
+        chevre.factory.role.organizationRole.RoleName.InventoryManager,
+        chevre.factory.role.organizationRole.RoleName.SellersOwner,
+        chevre.factory.role.organizationRole.RoleName.SellersInventoryManager
+    ];
+    const permissions = [
+        'admin.sellers.events.*'
+    ];
+    for (const roleName of roleNames) {
+        for (const permission of permissions) {
+            const result = await roleRepo.addPermissionIfNotExists({
+                roleName: { $eq: roleName },
+                permission
+            });
+            console.log('permission added.', result, roleName);
+        }
+    }
+
+    // roleNames = [
+    //     chevre.factory.role.organizationRole.RoleName.TicketClerk
+    // ];
+    // permissions = [
+    //     'admin.sellers.productOffers.read'
+    // ];
+    // for (const roleName of roleNames) {
+    //     for (const permission of permissions) {
+    //         const result = await roleRepo.addPermissionIfNotExists({
+    //             roleName: { $eq: roleName },
+    //             permission
+    //         });
+    //         console.log('permission added.', result, roleName);
+    //     }
+    // }
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/roles/removeConsolePermissionIfExists.ts

@@ -9,7 +9,7 @@ async function main() {
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
     const permissions = [
-        'eventOffers.*'
+        'products.read'
     ];
     for (const permission of permissions) {
         const roles = await roleRepo.projectFields(

package/example/src/chevre/roles/removePermissionIfExists.ts

@@ -9,12 +9,7 @@ async function main() {
     const roleRepo = await chevre.repository.Role.createInstance(mongoose.connection);
 
     const permissions = [
-        'tokens',
-        'authorizations.create',
-        'permits.read',
-        'tasks.read',
-        'transactionNumbers.write',
-        'chevre.admin'
+        'admin.sellers.productOffers.*'
     ];
     for (const permission of permissions) {
         const roles = await roleRepo.projectFields(

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -9,18 +9,16 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const eventRepo = await chevre.repository.Event.createInstance(mongoose.connection);
+    const noteRepo = await chevre.repository.NoteAboutOrder.createInstance(mongoose.connection);
 
     let updateResult: any;
 
-    updateResult = await eventRepo.unsetUnnecessaryFields({
+    updateResult = await noteRepo.unsetUnnecessaryFields({
         filter: {
-            // 'project.id': { $eq: '*' }
-            // 'location.maximumAttendeeCapacity': { $exists: true },
-            maximumPhysicalAttendeeCapacity: { $exists: true }
+            'about.identifier': { $exists: true }
         },
-        $unset: <any>{
-            'location.maximumAttendeeCapacity': 1
+        $unset: {
+            'about.identifier': 1
         }
     });
     console.log(updateResult);

package/example/src/objectId.ts

@@ -0,0 +1,12 @@
+
+// tslint:disable:no-console no-magic-numbers no-null-keyword
+import * as mongoose from 'mongoose';
+
+// const MONGOLAB_URI = String(process.env.MONGOLAB_URI);
+
+async function main() {
+    console.log(new mongoose.Types.ObjectId());
+}
+
+main()
+    .catch(console.error);

package/example/src/signPayload.ts

@@ -3,13 +3,18 @@ import * as jwt from 'jsonwebtoken';
 
 async function main(): Promise<void> {
     const payload = {
-        member: {
-            memberOf: {
-                identifier: 'bronze',
-                isTierOf: {
-                    identifier: 'DefaultMemberProgram'
-                }
-            }
+        /**
+         * アプリケーションオファーコード
+         */
+        identifier: 'LegacyReservation',
+        validFrom: '2025-10-20T00:00:00Z',
+        validThrough: '2025-10-25T00:00:00Z',
+        eligibleQuantity: { maxValue: 1 },
+        itemOffered: {
+            /**
+             * イベント識別子
+             */
+            identifier: '251025001001010900'
         }
     };
 

package/lib/chevre/errorHandler.d.ts

@@ -1,7 +1,11 @@
+/**
+ * https://www.mongodb.com/ja-jp/docs/manual/reference/error-codes/
+ */
 export declare enum MongoErrorCode {
-    DuplicateKey = 11000,
+    ConflictUpdateOperator = 40,
     MaxTimeMSExpired = 50,
-    ExceededTimeLimit = 262
+    ExceededTimeLimit = 262,
+    DuplicateKey = 11000
 }
 export declare function isMongoError(error: unknown): Promise<boolean>;
 export declare function handleMongoError(error: unknown): Promise<unknown>;

package/lib/chevre/errorHandler.js

@@ -24,11 +24,16 @@ exports.handleAWSError = handleAWSError;
 const http_status_1 = require("http-status");
 const factory_1 = require("./factory");
 let mongo;
+let mongooseError;
+/**
+ * https://www.mongodb.com/ja-jp/docs/manual/reference/error-codes/
+ */
 var MongoErrorCode;
 (function (MongoErrorCode) {
-    MongoErrorCode[MongoErrorCode["DuplicateKey"] = 11000] = "DuplicateKey";
+    MongoErrorCode[MongoErrorCode["ConflictUpdateOperator"] = 40] = "ConflictUpdateOperator";
     MongoErrorCode[MongoErrorCode["MaxTimeMSExpired"] = 50] = "MaxTimeMSExpired";
     MongoErrorCode[MongoErrorCode["ExceededTimeLimit"] = 262] = "ExceededTimeLimit";
+    MongoErrorCode[MongoErrorCode["DuplicateKey"] = 11000] = "DuplicateKey";
 })(MongoErrorCode || (exports.MongoErrorCode = MongoErrorCode = {}));
 function isMongoError(error) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -40,15 +45,21 @@ function isMongoError(error) {
 }
 function handleMongoError(error) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         if (mongo === undefined) {
             mongo = (yield Promise.resolve().then(() => require('mongoose'))).mongo;
         }
+        if (mongooseError === undefined) {
+            mongooseError = (yield Promise.resolve().then(() => require('mongoose'))).Error;
+        }
         let handledError = error;
         if (handledError instanceof mongo.MongoError || handledError instanceof mongo.MongoServerError) {
             switch (handledError.code) {
+                case MongoErrorCode.ConflictUpdateOperator:
+                    handledError = new factory_1.errors.Argument('', `Some updating fields conflict. code:${handledError.code} message:${handledError.message}`);
+                    break;
                 case MongoErrorCode.DuplicateKey:
                     handledError = new factory_1.errors.AlreadyInUse('', [], `Some fields already in use. code:${handledError.code} message:${handledError.message}`);
-                    // no op
                     break;
                 case MongoErrorCode.MaxTimeMSExpired:
                 case MongoErrorCode.ExceededTimeLimit:
@@ -60,6 +71,11 @@ function handleMongoError(error) {
         if (mongo.BSON.BSONError.isBSONError(handledError)) {
             handledError = new factory_1.errors.Argument('', handledError.message);
         }
+        // handle CastError(2025-10-27~)
+        // CastError: Cast to ObjectId failed for value "xxx" (type string) at path "_id" for model "xxxxxxxxxxxxx"
+        if (handledError instanceof mongooseError.CastError) {
+            handledError = new factory_1.errors.Argument(`${(_a = handledError.model) === null || _a === void 0 ? void 0 : _a.modelName}.${handledError.path}`, (handledError.reason instanceof Error) ? handledError.reason.message : handledError.message);
+        }
         return handledError;
     });
 }

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

@@ -1,11 +1,14 @@
 import { AnyExpression, Connection, FilterQuery, Types } from 'mongoose';
 import * as factory from '../factory';
-type IKeyOfProjection = keyof factory.categoryCode.ICategoryCode;
 type IUnset = {
-    [key in keyof Pick<factory.categoryCode.ICategoryCode, 'additionalProperty' | 'color' | 'image' | 'paymentMethod'>]?: 1;
+    [key in keyof Pick<factory.categoryCode.ICategoryCode, 'additionalProperty' | 'color' | 'image'>]?: 1;
 };
+export type CategorySetIdentifierExceptMovieTicketType = factory.categoryCode.CategorySetIdentifier;
+export type ICategoryCodeExceptMovieTicketType = Pick<factory.categoryCode.ICategoryCode, 'additionalProperty' | 'codeValue' | 'color' | 'id' | 'image' | 'name' | 'project' | 'typeOf' | 'inCodeSet'>;
+type IKeyOfProjection = keyof factory.categoryCode.ICategoryCode;
+type IKeyOfProjectionExceptMovieTicketType = keyof ICategoryCodeExceptMovieTicketType;
 /**
- * 区分リポジトリ
+ * 区分(決済カード区分を除く)リポジトリ
  */
 export declare class CategoryCodeRepo {
     private readonly categoryCodeModel;
@@ -15,41 +18,50 @@ export declare class CategoryCodeRepo {
         [field: string]: AnyExpression;
     };
     /**
-     * 集計検索(publicな属性検索が目的)
+     * 区分集計検索(publicな属性検索が目的)
      */
-    searchByAggregate(conditions: factory.categoryCode.ISearchConditions, inclusion: IKeyOfProjection[]): Promise<factory.categoryCode.ICategoryCode[]>;
+    findCategoryCodesByAggregate(conditions: factory.categoryCode.ISearchConditions, inclusion: IKeyOfProjectionExceptMovieTicketType[]): Promise<(ICategoryCodeExceptMovieTicketType & {
+        id: string;
+    })[]>;
     /**
-     * 検索
+     * 区分検索
      */
-    projectFields(params: factory.categoryCode.ISearchConditions, 
+    projectCategoryCodeFields(params: Omit<factory.categoryCode.ISearchConditions, 'inCodeSet'> & {
+        inCodeSet?: {
+            identifier?: {
+                $eq?: CategorySetIdentifierExceptMovieTicketType;
+                $in?: CategorySetIdentifierExceptMovieTicketType[];
+            };
+        };
+    }, 
     /**
      * 空の場合無効
      */
-    inclusion: IKeyOfProjection[]): Promise<(factory.categoryCode.ICategoryCode & {
+    inclusion: IKeyOfProjection[]): Promise<(ICategoryCodeExceptMovieTicketType & {
         id: string;
     })[]>;
-    save(params: {
+    saveCategoryCode(params: {
         id?: string;
-        attributes: factory.categoryCode.ICategoryCode & {
+        attributes: ICategoryCodeExceptMovieTicketType & {
             $unset?: IUnset;
         };
     }): Promise<{
         id: string;
     }>;
-    saveManyByCodeValue(params: {
-        attributes: factory.categoryCode.ICategoryCode;
+    saveCategoryCodesByCodeValue(params: {
+        attributes: ICategoryCodeExceptMovieTicketType;
         upsert?: boolean;
     }[]): Promise<void>;
     /**
      * 削除する
      */
-    deleteById(params: {
+    deleteCategoryCodeById(params: {
         id: string;
     }): Promise<void>;
     /**
      * プロジェクト指定で削除する
      */
-    deleteByProject(params: {
+    deleteCategoryCodesByProject(params: {
         project: {
             id: string;
         };