cc-core-cli 1.0.130 → 1.0.133

package/template/core/test/__mocks__/cc-core-lib.d.ts

@@ -0,0 +1,161 @@
+declare module '@shopstack/cc-core-lib/core' {
+  import type { Mock } from 'jest-mock';
+
+  // Mocked classes
+  export class BaseSchema {
+    constructor(definition?: any, options?: any);
+    _id: any;
+    id: string;
+    created_at: Date;
+    updated_at: Date;
+    created_by: string;
+    updated_by: string;
+    is_deleted: boolean;
+    is_active: boolean;
+    save: () => Promise<this>;
+    add: Mock;
+    pre: Mock;
+    post: Mock;
+    plugin: Mock;
+    index: Mock;
+    set: Mock;
+    virtual: Mock;
+    path: Mock;
+  }
+
+  export class BasePipelineProvider {
+    constructor();
+    init(settings: any): Promise<string>;
+    process(data: any): Promise<any>;
+    queue(data: any): Promise<any>;
+  }
+
+  export class BaseService<T = any> {
+    code: string;
+    protected model: any;
+    static prefix: string;
+    constructor(cls: any, model: any);
+    find(query: any): Promise<T[]>;
+    findOne(query: any, field?: string[], ignore?: any): Promise<T>;
+    findById(id: string): Promise<T>;
+    findByIdAndUpdate(id: string, update: any, options?: any): Promise<T>;
+    findOneAndUpdate(query: any, update: any, options?: any): Promise<T>;
+    create(data: any): Promise<T>;
+    update(id: string, data: any): Promise<T>;
+    delete(id: string): Promise<any>;
+  }
+
+  export class BaseModuleSettingService {
+    code: string;
+    protected setting: any;
+    cls: any;
+    constructor(code: string, setting: any, cls: any);
+    init(): Promise<string>;
+    getSetting(key?: string): Promise<any>;
+    setSetting(data: any, key?: string): Promise<any>;
+    defaultPermission(): Promise<any>;
+    setPermission(permission: any): Promise<any[]>;
+    getModuleConfig(): Promise<any>;
+    updateModuleConfig(config: any): Promise<any>;
+    getScheduleConfig(): Promise<any>;
+    updateScheduleConfig(config: any): Promise<any>;
+  }
+
+  export interface IModuleSetting {
+    defaultPermission(): Promise<any>;
+    setPermission(permission: any): Promise<any[]>;
+    getSetting(key?: string): Promise<any>;
+    setSetting(data: any, key?: string): Promise<any>;
+  }
+
+  export interface PipelineExecuteDto {
+    [key: string]: any;
+  }
+
+  export const CONST: {
+    CUSTOM_PROVIDERS: any[];
+    IGNORE_ENTITY: any[];
+  };
+
+  export const BaseSchemaFactory: {
+    createForClass: Mock<any, [any]>;
+  };
+
+  export const callAddQueueInternal: Mock<Promise<boolean>, [string, any]>;
+  export const callCountInternalService: Mock<Promise<number>, [string, any]>;
+  export const callFindInternalService: Mock<Promise<any>, [string, string?, any?, string?, string?, any?]>;
+  export const callListInternalService: Mock<Promise<any>, [string, any?, any?]>;
+  export const callCreateInternalService: Mock<Promise<any>, [string, any, any?, boolean?]>;
+  export const callDeleteInternalService: Mock<Promise<any>, [string, string]>;
+  export const callBulkDeleteInternalService: Mock<Promise<any>, [string, string[]]>;
+  export const callBulkUpdateInternalService: Mock<Promise<any>, [string, any[]]>;
+  export const callUpdateInternalService: Mock<Promise<any>, [string, string, any]>;
+  export const callInternalService: Mock<Promise<any>, [string, string, any?, any?]>;
+  export const callGetInternalService: Mock<Promise<any>, [string, string]>;
+
+  export const transformString: Mock<string, [string, any]>;
+  export const executeFunc: Mock<string, [string, any, any]>;
+  export const generateRunningNumber: Mock<string, [string, string, number]>;
+  export const loadEntity: Mock<Promise<any>, [string]>;
+  export const getNextExecuteTime: Mock<Date, []>;
+  export const transform: Mock<any, [any]>;
+  export const generateOtp: Mock<Promise<string>, []>;
+  export const validateOtp: Mock<Promise<boolean>, [string, string]>;
+  export const initQueue: Mock<Promise<boolean>, [string, any]>;
+  export const randomString: Mock<string, [number?]>;
+  export const convertConditionToMongoQuery: Mock<any, [any]>;
+  export const addSystemSchedule: Mock<void, [any]>;
+
+  export interface SearchResultDto {
+    rows: any[];
+    total: number;
+    page: number;
+    limit: number;
+  }
+
+  export class EntitiesService {
+    refreshSystemSchema: Mock<Promise<boolean>, [any, any, any, any, any?]>;
+  }
+
+  export class SettingService {
+    getSetting: Mock<Promise<any>, [string?]>;
+    setSetting: Mock<Promise<any>, [any, string?]>;
+  }
+
+  export const UserPermission: {
+    creator: string;
+    viewer: string;
+    access_denied: string;
+  };
+
+  export const PointProgramRuleType: {
+    BIRTHDAY: string;
+    SPEND: string;
+    FIXED: string;
+    QR_SCAN: string;
+    GAME_REWARD: string;
+    SIGNUP: string;
+  };
+
+  export interface LayoutEntity {
+    name: string;
+    code: string;
+    type: string[];
+    detail: any;
+    list?: any;
+    allow_workflow_actions?: boolean;
+    [key: string]: any; // Allow additional properties
+  }
+
+  export interface WorkflowEntity {
+    [key: string]: any; // Allow any properties for workflow
+  }
+
+  export class BaseController {
+    constructor(service: any);
+  }
+
+  // Decorators
+  export const Basic: () => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
+  export const Public: () => (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
+}

package/template/core/test/__mocks__/cc-core-lib.js

@@ -0,0 +1,311 @@
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+// const jest = require('jest-mock');
+
+// ---- Mock BaseSchema ----
+class BaseSchema {
+  constructor(definition = {}, options = {}) {
+    this.definition = definition;
+    this.options = options;
+    this._id = new mongoose.Types.ObjectId();
+    this.id = this._id.toString();
+    this.created_at = new Date();
+    this.updated_at = new Date();
+    this.created_by = 'test-user';
+    this.updated_by = 'test-user';
+    this.is_deleted = false;
+    this.is_active = true;
+  }
+
+  save() {
+    return Promise.resolve(this);
+  }
+
+  // Add mock schema methods
+  add = jest.fn();
+  pre = jest.fn().mockReturnThis();
+  post = jest.fn().mockReturnThis();
+  plugin = jest.fn().mockReturnThis();
+  index = jest.fn().mockReturnThis();
+  set = jest.fn().mockReturnThis();
+  virtual = jest.fn().mockReturnThis();
+  path = jest.fn().mockReturnThis();
+}
+
+// ---- Mock Services & Classes ----
+class BasePipelineProvider {
+  constructor() {
+    this._settings = null;
+  }
+
+  async init(settings) {
+    this._settings = settings;
+    return '[PIPELINE] Initialized';
+  }
+
+  async process(data) {
+    return data;
+  }
+
+  async queue(data) {
+    return data;
+  }
+}
+
+class BaseService {
+  constructor(cls, model) {
+    this.cls = cls;
+    this.model = {
+      create: jest.fn().mockImplementation((data) => {
+        console.log('🔥 MOCK: BBaseService.model.create called:', data);
+        return data;
+      })
+    };
+  }
+
+  static prefix = '';
+
+  async find(query) {
+    const result = this.model.find(query);
+    return result.exec ? result.exec() : result;
+  }
+
+  async findOne(query, field, ignore) {
+    const result = this.model.findOne(query);
+    return result.exec ? result.exec() : result;
+  }
+
+  async findById(id) {
+    const result = this.model.findById(id);
+    return result.exec ? result.exec() : result;
+  }
+
+  async findByIdAndUpdate(id, update, options) {
+    const result = this.model.findByIdAndUpdate(id, update, options);
+    return result.exec ? result.exec() : result;
+  }
+
+  async findOneAndUpdate(query, update, options) {
+    const result = this.model.findOneAndUpdate(query, update, options);
+    return result.exec ? result.exec() : result;
+  }
+
+  async create(data) {
+    return data;
+  }
+
+  async update(id, data) {
+    return { _id: id, ...data };
+  }
+
+  async delete(id) {
+    return { _id: id, deleted: true };
+  }
+}
+
+class BaseModuleSettingService {
+  constructor(code, setting, cls) {
+    this.code = code;
+    this.setting = setting;
+    this.cls = cls;
+  }
+
+  async init() {
+    return 'Initialized';
+  }
+
+  async getSetting(key) {
+    // Use the injected setting service if available, otherwise return default data
+    if (this.setting && this.setting.getSetting) {
+      return await this.setting.getSetting(key);
+    }
+    return {
+      transaction: {
+        format: 'TR${ _date("YYMMDD","7h","") }',
+        running: 4,
+      },
+    };
+  }
+
+  async setSetting(data, key) {
+    // Use the injected setting service if available, otherwise return the data
+    if (this.setting && this.setting.setSetting) {
+      return await this.setting.setSetting(data, key);
+    }
+    return data;
+  }
+
+  async defaultPermission() {
+    return {};
+  }
+
+  async setPermission(permission) {
+    return [];
+  }
+
+  async getModuleConfig() {
+    return {
+      point_expiration_days: 30,
+      birthday_points: 100,
+      signup_points: 50,
+      programs: [
+        { rule_type: 'PURCHASE', points: 10, min_spend: 100, max_points: 1000 },
+        { rule_type: 'QR_SCAN', points: 5 },
+        { rule_type: 'GAME_REWARD', points: 20 },
+      ],
+    };
+  }
+
+  async updateModuleConfig(config) {
+    return config;
+  }
+
+  async getScheduleConfig() {
+    return {};
+  }
+
+  async updateScheduleConfig(config) {
+    return config;
+  }
+}
+
+class BaseController {
+  constructor(service) {
+    this.service = service;
+  }
+}
+
+// ---- Helper Mocks ----
+const BaseSchemaFactory = {
+  createForClass: jest.fn((cls) => ({
+    prototype: new cls(),
+  })),
+};
+
+const callAddQueueInternal = jest.fn().mockResolvedValue(true);
+const callCountInternalService = jest.fn().mockResolvedValue(1);
+const callFindInternalService = jest.fn().mockResolvedValue({});
+const callListInternalService = jest.fn().mockResolvedValue({ rows: [] });
+const callCreateInternalService = jest.fn().mockResolvedValue({});
+const callDeleteInternalService = jest.fn().mockResolvedValue({});
+const callBulkDeleteInternalService = jest.fn().mockResolvedValue({});
+const callBulkUpdateInternalService = jest.fn().mockResolvedValue({});
+const callUpdateInternalService = jest.fn().mockResolvedValue({});
+const callInternalService = jest.fn().mockResolvedValue({});
+const callGetInternalService = jest.fn();
+
+const transformString = jest.fn((str, data) => str);
+const executeFunc = jest.fn((str, entity, data) => str);
+const generateRunningNumber = jest.fn((prefix, template, running) => `${template}${running}`);
+const loadEntity = jest.fn().mockResolvedValue({ id: 'test-entity' });
+const getNextExecuteTime = jest.fn(() => new Date());
+const transform = jest.fn((data) => data);
+const generateOtp = jest.fn().mockResolvedValue({ ref: 'test-ref', otp: '123456' });
+const validateOtp = jest.fn().mockResolvedValue(true);
+const initQueue = jest.fn().mockResolvedValue(true);
+const randomString = jest.fn((length) => 'a'.repeat(length || 8));
+const convertConditionToMongoQuery = jest.fn((condition) => condition);
+const addSystemSchedule = jest.fn();
+
+// Basic decorator mock - works for both class and method decorators
+const Basic = () => {
+  return (target, propertyKey, descriptor) => {
+    // If descriptor is provided, it's a method decorator
+    if (descriptor) {
+      return descriptor;
+    }
+    // Otherwise, it's a class decorator
+    return target;
+  };
+};
+
+// Public decorator mock
+const Public = () => {
+  return (target, propertyKey, descriptor) => {
+    // If descriptor is provided, it's a method decorator
+    if (descriptor) {
+      return descriptor;
+    }
+    // Otherwise, it's a class decorator
+    return target;
+  };
+};
+
+class EntitiesService {
+  refreshSystemSchema = jest.fn().mockResolvedValue(true);
+}
+
+const SettingService = jest.fn(() => ({
+  getSetting: jest.fn().mockResolvedValue({}),
+  setSetting: jest.fn().mockResolvedValue({}),
+}));
+
+const UserPermission = {
+  creator: 'creator',
+  viewer: 'viewer',
+  access_denied: 'access_denied',
+};
+
+// Mock LayoutEntity (interface, so just an empty object)
+const LayoutEntity = {};
+
+// Mock WorkflowEntity (interface, so just an empty object)
+const WorkflowEntity = {};
+
+// Mock IModuleSetting (interface, so just an empty object)
+const IModuleSetting = {};
+
+// Mock PipelineExecuteDto (interface, so just an empty object)
+const PipelineExecuteDto = {};
+
+// Mock CONST object
+const CONST = {
+  CUSTOM_PROVIDERS: [],
+  IGNORE_ENTITY: []
+};
+
+// ---- Export Everything ----
+module.exports = {
+  BaseSchema,
+  BaseService,
+  BaseController,
+  BasePipelineProvider,
+  BaseModuleSettingService,
+  BaseSchemaFactory,
+  callAddQueueInternal,
+  callCountInternalService,
+  callFindInternalService,
+  callListInternalService,
+  callCreateInternalService,
+  callDeleteInternalService,
+  callBulkDeleteInternalService,
+  callBulkUpdateInternalService,
+  callUpdateInternalService,
+  callInternalService,
+  callGetInternalService,
+  loadEntity,
+  getNextExecuteTime,
+  transformString,
+  executeFunc,
+  generateRunningNumber,
+  EntitiesService,
+  SettingService,
+  UserPermission,
+  LayoutEntity,
+  WorkflowEntity,
+  IModuleSetting,
+  PipelineExecuteDto,
+  CONST,
+  transform,
+  generateOtp,
+  validateOtp,
+  initQueue,
+  randomString,
+  Basic,
+  Public,
+  convertConditionToMongoQuery,
+  addSystemSchedule
+};
+
+// Optional: ESM Compatibility
+module.exports.default = module.exports;

package/template/core/test/__mocks__/pdf-img-convert.js

@@ -0,0 +1,5 @@
+module.exports = {
+  convert: jest.fn().mockResolvedValue([]),
+  fromPath: jest.fn().mockResolvedValue([]),
+  fromBuffer: jest.fn().mockResolvedValue([])
+}; 

package/template/core/test/jest.setup.ts

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+
+// Configure Mongoose
+mongoose.set('strictQuery', false);
+
+// Mock console methods to reduce noise in tests
+global.console = {
+  ...console,
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+};
+
+// Mock cc-core-lib
+jest.mock('@shopstack/cc-core-lib/core');
+
+// Clear mocks before each test
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+// Disconnect Mongoose after all tests
+afterAll(async () => {
+  await mongoose.disconnect();
+}); 

package/template/core/tsconfig.json

@@ -1,18 +1,18 @@
 {
     "compilerOptions": {
-        "module": "commonjs",
-        "declaration": true,
-        "removeComments": true,
-        "emitDecoratorMetadata": true,
-        "experimentalDecorators": true,
-        "target": "es2017",
-        "sourceMap": true,
-        "outDir": "./dist",
-        "baseUrl": "./",
-        "incremental": true,
-        "allowSyntheticDefaultImports": true,
-        "resolveJsonModule": true,
-        "skipLibCheck": true,
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true
     },
     "exclude": [
         "node_modules",

package/template/core/tsconfig.test.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "paths": {
+      "@shopstack/cc-core-lib/core": [
+        "test/__mocks__/cc-core-lib"
+      ]
+    }
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/__tests__/**/*",
+    "test/__mocks__/*.d.ts"
+  ]
+}