@positivegrid/pg-mongoose-schema 27.8.5 → 28.0.0-beta.3

package/dist/index.mjs

@@ -0,0 +1,5128 @@
+import debug from "debug";
+import _ from "lodash";
+import mongooseLeanVirtuals from "mongoose-lean-virtuals";
+import deepPopulateFactory from "mongoose-deep-populate";
+import isSubset from "is-subset";
+import moment from "moment";
+import crypto from "node:crypto";
+import { ApiErrorCode } from "@positivegrid/pg-error";
+import isEmail from "is-email";
+import randomString from "random-string";
+//#region src/models/banks.ts
+debug("model:banks");
+function buildBanks(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const BankListSchema = new Schema({
+		name: {
+			type: String,
+			required: true
+		},
+		creator_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		description: { type: String },
+		preset_for: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "bank_list" });
+	BankListSchema.index({
+		creator_id: 1,
+		preset_for: 1
+	});
+	const BankPresetsSchema = new Schema({
+		name: {
+			type: String,
+			index: true,
+			required: true
+		},
+		creator_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		bank_id: {
+			type: ObjectId,
+			ref: "BankList",
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		description: { type: String },
+		preset_data: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		preset_meta: { type: Schema.Types.Mixed },
+		image_url: { type: String },
+		thumb_url: { type: String },
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "bank_presets",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	BankPresetsSchema.index({
+		creator_id: 1,
+		bank_id: 1,
+		name: 1
+	}, { unique: true });
+	return {
+		BankPresets: mongoose.model("BankPresets", BankPresetsSchema),
+		BankList: mongoose.model("BankList", BankListSchema)
+	};
+}
+//#endregion
+//#region src/models/device.ts
+function buildDevice(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const DeviceSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		device_udid: {
+			type: String,
+			required: true,
+			unique: true
+		},
+		display_name: { type: String },
+		mac_address: { type: String },
+		machine_id: { type: String },
+		platform: { type: String },
+		architecture: { type: String },
+		os_version: { type: String },
+		model: { type: String },
+		activate_random: { type: String },
+		other_info: { type: String },
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_device" });
+	const IapActivationSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		device_id: {
+			type: ObjectId,
+			ref: "Device",
+			required: true
+		},
+		main_product: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "iap_activation" });
+	const ActivationStatusSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		device_id: {
+			type: ObjectId,
+			ref: "Device",
+			required: true
+		},
+		license_id: {
+			type: ObjectId,
+			ref: "License",
+			required: true
+		},
+		status: {
+			type: Number,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_activationstatus" });
+	DeviceSchema.static({ getFeaturedPresetListByCondition(queryObj, cb) {
+		this.find(queryObj).select("-is_shown -order").then((docs) => cb(null, docs), (err) => cb(err));
+	} });
+	return {
+		Device: mongoose.model("Device", DeviceSchema),
+		ActivationStatus: mongoose.model("ActivationStatus", ActivationStatusSchema),
+		IapActivation: mongoose.model("IapActivation", IapActivationSchema)
+	};
+}
+//#endregion
+//#region src/models/featuredList.ts
+function buildFeaturedList(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const FeaturedListSchema = new Schema({
+		title: {
+			type: String,
+			required: true
+		},
+		description: {
+			type: String,
+			default: null
+		},
+		image_url: {
+			type: String,
+			default: null
+		},
+		thumb_url: {
+			type: String,
+			default: null
+		},
+		embed_url: {
+			type: String,
+			default: null
+		},
+		bg_url: {
+			type: String,
+			default: null
+		},
+		order: {
+			type: Number,
+			default: 0
+		},
+		type: {
+			type: String,
+			default: null
+		},
+		permission: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		metadata: {
+			type: Array,
+			default: null
+		},
+		is_shown: {
+			type: Boolean,
+			default: false
+		},
+		list_for: {
+			type: String,
+			required: true,
+			unique: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "jamup_featuredpresetlist",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const FeaturedPresetSchema = new Schema({
+		featured_list_id: {
+			type: ObjectId,
+			ref: "FeaturedList",
+			required: true
+		},
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		order: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_featuredpreset" });
+	FeaturedPresetSchema.index({
+		featured_list_id: 1,
+		preset_id: 1
+	}, { unique: true });
+	FeaturedListSchema.plugin(mongooseLeanVirtuals);
+	FeaturedListSchema.static({
+		getFeaturedPresetListByCondition(reqQuery) {
+			const defaultQuery = {
+				$or: [{ permission: { $exists: false } }, { permission: null }],
+				is_shown: true,
+				list_for: "jamup"
+			};
+			const queryObj = _.has(reqQuery, "list_for") ? _.assign({}, defaultQuery, { list_for: reqQuery.list_for }) : defaultQuery;
+			return this.find(queryObj).sort({ order: 1 }).select("-is_shown").lean({ virtuals: true }).exec();
+		},
+		getLimitedPresetLists(reqQuery) {
+			const defaultQuery = {
+				$and: [{ permission: { $exists: true } }, { permission: { $ne: null } }],
+				is_shown: true,
+				list_for: "jamup"
+			};
+			const queryObj = _.has(reqQuery, "list_for") ? _.assign({}, defaultQuery, { list_for: reqQuery.list_for }) : defaultQuery;
+			return this.find(queryObj).sort({ order: 1 }).select("-is_shown").lean({ virtuals: true }).exec();
+		}
+	});
+	FeaturedListSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	return {
+		FeaturedList: mongoose.model("FeaturedList", FeaturedListSchema),
+		FeaturedPreset: mongoose.model("FeaturedPreset", FeaturedPresetSchema)
+	};
+}
+//#endregion
+//#region src/models/hardware.ts
+const log$7 = debug("model:promo");
+function _identifyHardwareByModel(model) {
+	switch (model) {
+		case "G1": return "head";
+		case "G2": return "rack";
+		case "G3": return "mini";
+		case "S": return "spark";
+		default: return false;
+	}
+}
+function _parseHardwareSerialNumber(hwSn) {
+	if (!_.isString(hwSn)) throw new Error(`Invalid hardware series number format: ${hwSn}`);
+	if (/^S/.test(hwSn)) {
+		const hwModel = hwSn.slice(0, 1);
+		const hwWattage = hwSn.slice(1, 4);
+		const hwProductType = hwSn.slice(4, 5);
+		const hwVersion = hwSn.slice(5, 6);
+		const hwYear = hwSn.slice(6, 7);
+		const hwMonth = hwSn.slice(7, 8);
+		const hwPattern = [
+			`hwModel:${hwModel}`,
+			`hwWattage:${hwWattage}`,
+			`hwProductType:${hwProductType}`,
+			`hwVersion:${hwVersion}`,
+			`hwYear:${hwYear}`,
+			`hwMonth:${hwMonth}`
+		];
+		const hwName = _identifyHardwareByModel(hwModel);
+		if (hwName === false) throw new Error(`Cannot identify hardware model: ${hwModel}`);
+		return {
+			hwName,
+			hwModel,
+			hwWattage,
+			hwProductType,
+			hwVersion,
+			hwYear,
+			hwMonth,
+			hwPattern
+		};
+	}
+	const hwModel = hwSn.slice(0, 2);
+	const hwWattage = hwSn.slice(2, 4);
+	const hwVersion = hwSn.slice(4, 7);
+	const hwProductionPhase = hwSn.slice(7, 9);
+	const hwName = _identifyHardwareByModel(hwModel);
+	const hwPattern = [
+		`hwModel:${hwModel}`,
+		`hwWattage:${hwWattage}`,
+		`hwVersion:${hwVersion}`,
+		`hwProductionPhase:${hwProductionPhase}`
+	];
+	if (hwName === false) throw new Error(`Cannot identify hardware model: ${hwModel}`);
+	return {
+		hwModel,
+		hwWattage,
+		hwVersion,
+		hwProductionPhase,
+		hwName,
+		hwPattern
+	};
+}
+function buildHardware(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const HardwareSeriesNumberSchema = new Schema({
+		hw_sn: {
+			type: String,
+			required: true
+		},
+		channel: {
+			type: String,
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		metadata: { type: Schema.Types.Mixed },
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "hardware_seriesnumber" });
+	const HardwareActivationMetaSchema = new Schema({
+		pattern: {
+			type: [String],
+			required: true
+		},
+		hw_sn_pattern: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		hw_activate_license: [{
+			type: ObjectId,
+			ref: "Product"
+		}],
+		status: {
+			type: Number,
+			required: true,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "hardware_activation_meta" });
+	const HardwareActivationRecordSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		hw_sn_id: {
+			type: ObjectId,
+			ref: "HardwareSeriesNumber",
+			required: true
+		},
+		hw_meta_id: {
+			type: ObjectId,
+			ref: "HardwareActivationMeta",
+			default: null
+		},
+		hw_partner_id: {
+			type: ObjectId,
+			ref: "PartnerCoupon",
+			default: null
+		},
+		activate_license: [{
+			type: ObjectId,
+			ref: "License"
+		}],
+		status: {
+			type: Number,
+			required: true,
+			default: 1
+		},
+		activate_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "hardware_activation_record" });
+	const HardwareActivationConflictSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		hw_sn_id: {
+			type: ObjectId,
+			ref: "HardwareSeriesNumber",
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "hardware_activation_conflict" });
+	const PartnerCouponSchema = new Schema({
+		partner: {
+			type: String,
+			required: true
+		},
+		code: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		hw_sn_id: {
+			type: ObjectId,
+			ref: "HardwareSeriesNumber"
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "partner_coupon" });
+	const WarehouseInventorySchema = new Schema({
+		warehouse: {
+			type: String,
+			required: true
+		},
+		country: [{ type: String }],
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		items: [{
+			sku: {
+				type: String,
+				required: true
+			},
+			type: {
+				type: String,
+				required: true
+			},
+			total: {
+				type: Number,
+				required: true
+			},
+			available: {
+				type: Number,
+				required: true
+			},
+			transit: {
+				type: Number,
+				required: true
+			},
+			lock: {
+				type: Number,
+				required: true
+			}
+		}],
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "warehouse_inventory" });
+	WarehouseInventorySchema.index({ warehouse: 1 }, { unique: true });
+	WarehouseInventorySchema.index({ country: 1 });
+	const ItemInventoryHistorySchema = new Schema({
+		warehouse: {
+			type: String,
+			required: true
+		},
+		sku: {
+			type: String,
+			required: true
+		},
+		total: {
+			type: Number,
+			required: true
+		},
+		available: {
+			type: Number,
+			required: true
+		},
+		transit: {
+			type: Number,
+			required: true
+		},
+		lock: {
+			type: Number,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "item_inventory_history" });
+	ItemInventoryHistorySchema.index({
+		warehouse: 1,
+		sku: 1
+	});
+	const CountryHardwareSkuSchema = new Schema({
+		country: [{ type: String }],
+		items: [{
+			name: { type: String },
+			hw_sku: [{ type: String }]
+		}],
+		level: [{
+			level: { type: Number },
+			min: { type: Number },
+			max: { type: Number },
+			days: { type: String }
+		}],
+		sale_threshold: { type: Number },
+		sale_region: { type: String },
+		sale_overwrite: [{
+			level: { type: Number },
+			days: { type: String }
+		}],
+		not_sold: [{ type: String }],
+		not_sold_threshold: { type: Number },
+		express_ship_days: { type: String },
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "country_hardaware_sku" });
+	HardwareSeriesNumberSchema.static({
+		parseHardwareSeriesNumber(hwSn) {
+			return new Promise((resolve, reject) => {
+				try {
+					resolve(_parseHardwareSerialNumber(hwSn));
+				} catch (e) {
+					reject(e);
+				}
+			});
+		},
+		parseHardwareSerialNumberNoPromise(hwSn) {
+			try {
+				return _parseHardwareSerialNumber(hwSn);
+			} catch (e) {
+				return e.message;
+			}
+		}
+	});
+	HardwareActivationMetaSchema.static({ async findMostMatchingMeta(snPatternArr, opts = {}) {
+		try {
+			const allMatch = await this.find({ pattern: { $in: snPatternArr } }).sort({ created_on: -1 }).lean().exec();
+			if (!allMatch || allMatch.length <= 0) {
+				if (opts.allowEmpty === true) return null;
+				throw new Error("Cannot find any activation meta match the SN pattern");
+			}
+			let mostMatchingMeta = {};
+			let mostMatchingNumber = 0;
+			allMatch.forEach((metaItem) => {
+				if (_.isArray(metaItem.pattern) && metaItem.pattern.length > 0) {
+					const matchItem = _.intersection(metaItem.pattern, snPatternArr);
+					if (matchItem.length === metaItem.pattern.length && matchItem.length > mostMatchingNumber) {
+						mostMatchingMeta = metaItem;
+						mostMatchingNumber = matchItem.length;
+					}
+				}
+			});
+			if (_.isEmpty(mostMatchingMeta) || mostMatchingNumber === 0) {
+				if (opts.allowEmpty === true) return null;
+				throw new Error("Cannot find any activation meta match the SN pattern");
+			}
+			return mostMatchingMeta;
+		} catch (err) {
+			log$7("ERROR:findMostMatchingMeta %o", err);
+			throw err;
+		}
+	} });
+	return {
+		HardwareActivationRecord: mongoose.model("HardwareActivationRecord", HardwareActivationRecordSchema),
+		HardwareActivationMeta: mongoose.model("HardwareActivationMeta", HardwareActivationMetaSchema),
+		HardwareSeriesNumber: mongoose.model("HardwareSeriesNumber", HardwareSeriesNumberSchema),
+		HardwareActivationConflict: mongoose.model("HardwareActivationConflict", HardwareActivationConflictSchema),
+		PartnerCoupon: mongoose.model("PartnerCoupon", PartnerCouponSchema),
+		WarehouseInventory: mongoose.model("WarehouseInventory", WarehouseInventorySchema),
+		ItemInventoryHistory: mongoose.model("ItemInventoryHistory", ItemInventoryHistorySchema),
+		CountryHardwareSku: mongoose.model("CountryHardwareSku", CountryHardwareSkuSchema)
+	};
+}
+//#endregion
+//#region src/models/homeConfig.ts
+function buildHomeConfig(mongoose) {
+	const { Schema } = mongoose;
+	const DataSourceSchema = new Schema({
+		type: {
+			type: String,
+			enum: [
+				"tone_theme_query",
+				"tone_theme_ids",
+				"tone_theme_id"
+			],
+			required: true
+		},
+		tone_theme_id: {
+			type: String,
+			default: null
+		},
+		query: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		ids: [{ type: String }],
+		limit: {
+			type: Number,
+			default: 12
+		}
+	}, { _id: false });
+	const SectionSchema = new Schema({
+		section_type: {
+			type: String,
+			enum: [
+				"tone_theme_banner",
+				"tone_theme_list",
+				"tone_theme_lists"
+			],
+			required: true
+		},
+		title: {
+			type: String,
+			default: null
+		},
+		order: {
+			type: Number,
+			required: true
+		},
+		data_source: {
+			type: DataSourceSchema,
+			required: true
+		}
+	}, { _id: false });
+	const HomeConfigSchema = new Schema({
+		config_for: {
+			type: String,
+			required: true
+		},
+		locale: {
+			type: String,
+			default: "en"
+		},
+		sections: [SectionSchema],
+		is_active: {
+			type: Boolean,
+			default: false
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "home_config" });
+	HomeConfigSchema.index({
+		config_for: 1,
+		locale: 1,
+		is_active: 1
+	});
+	return mongoose.model("HomeConfig", HomeConfigSchema);
+}
+//#endregion
+//#region src/models/oauth.ts
+function buildOauth(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const deepPopulate = deepPopulateFactory(mongoose);
+	const clientSchema = new Schema({
+		name: {
+			type: String,
+			required: true
+		},
+		clientId: {
+			type: String,
+			required: true
+		},
+		clientSecret: {
+			type: String,
+			required: true
+		}
+	}, {
+		collection: "auth_clients",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const AuthorizationCodeSchema = new Schema({
+		code: {
+			type: String,
+			required: true
+		},
+		clientId: {
+			type: ObjectId,
+			ref: "OathClient",
+			required: true
+		},
+		redirectURI: {
+			type: String,
+			required: true
+		},
+		userId: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		scopes: [{
+			type: String,
+			required: true
+		}],
+		expiresAt: {
+			type: Date,
+			required: true
+		},
+		codeChallenge: { type: String },
+		codeChallengeMethod: {
+			type: String,
+			default: "S256"
+		},
+		date: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "auth_authorizationCodes",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	AuthorizationCodeSchema.plugin(deepPopulate, {});
+	const AccessTokenSchema = new Schema({
+		token: {
+			type: String,
+			required: true
+		},
+		expirationDate: {
+			type: Date,
+			required: true
+		},
+		userId: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		clientId: {
+			type: ObjectId,
+			ref: "OathClient",
+			required: true
+		},
+		scopes: [{
+			type: String,
+			required: true
+		}],
+		date: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "auth_accessTokens",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const RefreshTokenSchema = new Schema({
+		refreshToken: {
+			type: String,
+			required: true
+		},
+		clientId: {
+			type: ObjectId,
+			ref: "OathClient",
+			required: true
+		},
+		expirationDate: {
+			type: Date,
+			required: true
+		},
+		userId: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		scopes: [{
+			type: String,
+			required: true
+		}],
+		date: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "auth_refreshTokens",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	return {
+		OauthClient: mongoose.model("OauthClient", clientSchema),
+		RefreshTokens: mongoose.model("RefreshTokens", RefreshTokenSchema),
+		AccessToken: mongoose.model("AccessToken", AccessTokenSchema),
+		AuthorizationCode: mongoose.model("AuthorizationCode", AuthorizationCodeSchema)
+	};
+}
+//#endregion
+//#region src/models/partner.ts
+const log$6 = debug("model:partner");
+const OEM_PROMOTION_TYPE = ["discount_coupon"];
+function _identifyItemTypeBySku(sku) {
+	if (/^B(.*)/.test(sku)) return "bundle";
+	if (/^(L|C|U)(.*)/.test(sku)) return "product";
+	return false;
+}
+function buildPartner(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const PartnerSalesMetaSchema = new Schema({
+		partner_name: {
+			type: String,
+			required: true
+		},
+		sales_product: {
+			type: ObjectId,
+			ref: "Product",
+			default: null
+		},
+		sales_bundle: {
+			type: ObjectId,
+			ref: "Bundle",
+			default: null
+		},
+		b2b_redeem_id: {
+			type: Number,
+			default: null
+		},
+		pg_sales_price: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		purchase_price: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_partner_sales_meta" });
+	PartnerSalesMetaSchema.index({
+		partner_name: 1,
+		status: 1
+	});
+	PartnerSalesMetaSchema.index({
+		sales_product: 1,
+		sales_bundle: 1,
+		status: 1
+	});
+	const PartnerRedeemSchema = new Schema({
+		partner_name: {
+			type: String,
+			required: true
+		},
+		sales_item_id: {
+			type: ObjectId,
+			ref: "PartnerSalesMeta",
+			required: true
+		},
+		purchase_price: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		redeem_keycode: {
+			type: String,
+			required: true
+		},
+		buyer: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		order_number: {
+			type: String,
+			default: null
+		},
+		status: {
+			type: Number,
+			required: true,
+			default: 1
+		},
+		metadata: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_partner_redeem" });
+	const PartnerSalesHistorySchema = new Schema({
+		partner_name: {
+			type: String,
+			required: true
+		},
+		sku: {
+			type: String,
+			required: true
+		},
+		title: {
+			type: String,
+			required: true
+		},
+		previous_price: {
+			type: Number,
+			required: true
+		},
+		current_price: {
+			type: Number,
+			required: true
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_partner_sales_history" });
+	PartnerSalesHistorySchema.index({
+		partner_name: 1,
+		sku: 1
+	});
+	const B2bRedeemOrderSchema = new Schema({
+		dealer_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		order_id: {
+			type: Number,
+			default: null,
+			required: true
+		},
+		order_detail: [{
+			product_id: {
+				type: ObjectId,
+				ref: "jamup_product",
+				default: null
+			},
+			bundle_id: {
+				type: ObjectId,
+				ref: "jamup_bundle",
+				default: null
+			},
+			quantity: {
+				type: Number,
+				default: 0
+			}
+		}],
+		order_amount: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_b2b_redeem_order" });
+	B2bRedeemOrderSchema.index({
+		dealer_id: 1,
+		order_id: 1
+	});
+	const B2bRedeemSchema = new Schema({
+		redeem_code: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		redeem_order_id: {
+			type: ObjectId,
+			ref: "pg_b2b_redeem_order",
+			required: true
+		},
+		apply_user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			default: null,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_b2b_redeem" });
+	const B2bDealerSchema = new Schema({
+		dealer_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		business_name: {
+			type: String,
+			required: true
+		},
+		business_address: {
+			type: String,
+			required: true
+		},
+		business_phone: {
+			type: String,
+			required: true
+		},
+		business_website: {
+			type: String,
+			default: null
+		},
+		business_tax_id: {
+			type: String,
+			default: null
+		},
+		business_vat_id: {
+			type: String,
+			default: null
+		},
+		members: [{ type: String }],
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "b2b_dealer_profile" });
+	const OemRedeemPromotionSchema = new Schema({
+		redeem_product: {
+			type: String,
+			required: true
+		},
+		product_type: {
+			type: String,
+			required: true
+		},
+		partner_name: {
+			type: String,
+			required: true
+		},
+		promotion_type: {
+			type: String,
+			enum: OEM_PROMOTION_TYPE,
+			required: true
+		},
+		promotion_data: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_oem_redeem_promotion" });
+	PartnerSalesMetaSchema.static({
+		getPartnerSalesMeta(partnerName) {
+			return this.aggregate([
+				{ $match: {
+					partner_name: partnerName,
+					status: 1
+				} },
+				{ $lookup: {
+					from: "jamup_bundle",
+					foreignField: "_id",
+					localField: "sales_bundle",
+					as: "bundle"
+				} },
+				{ $lookup: {
+					from: "jamup_product",
+					foreignField: "_id",
+					localField: "sales_product",
+					as: "product"
+				} }
+			]).exec();
+		},
+		async getSalesMetaWithSku(sku, partnerName) {
+			const skuType = _identifyItemTypeBySku(sku);
+			if (skuType === "bundle") {
+				const data = await this.aggregate([
+					{ $match: {
+						partner_name: partnerName,
+						status: 1
+					} },
+					{ $lookup: {
+						from: "jamup_bundle",
+						foreignField: "_id",
+						localField: "sales_bundle",
+						as: "sales"
+					} },
+					{ $unwind: "$sales" },
+					{ $match: { "sales.sku": sku } }
+				]).exec();
+				if (Array.isArray(data) && data.length > 1) throw new Error(`Incorrect bundle sku settings: ${sku}.`);
+				return data[0];
+			}
+			if (skuType === "product") {
+				const data = await this.aggregate([
+					{ $match: {
+						partner_name: partnerName,
+						status: 1
+					} },
+					{ $lookup: {
+						from: "jamup_product",
+						foreignField: "_id",
+						localField: "sales_product",
+						as: "sales"
+					} },
+					{ $unwind: "$sales" },
+					{ $match: { "sales.sku": sku } }
+				]).exec();
+				if (Array.isArray(data) && data.length > 1) throw new Error(`Incorrect product sku settings: ${sku}.`);
+				return data[0];
+			}
+			throw new Error(`Invalid item sku: ${sku}`);
+		}
+	});
+	OemRedeemPromotionSchema.static({ async findRedeemFullfillPromotion(redeemData) {
+		try {
+			if (!_.has(redeemData, "metadata.OEM_Name")) throw new Error("This is not a OEM redeem code.");
+			if (!_.has(redeemData, "metadata.product_name") || !_.has(redeemData, "metadata.type")) throw new Error("This is not a valid redeem code.");
+			return this.find({
+				redeem_product: redeemData.metadata.product_name,
+				product_type: redeemData.metadata.type,
+				partner_name: redeemData.metadata.OEM_Name,
+				status: 1
+			}).exec();
+		} catch (err) {
+			log$6("ERR:findRedeemFullfillPromotion %o", err);
+			throw err;
+		}
+	} });
+	return {
+		PartnerSalesMeta: mongoose.model("PartnerSalesMeta", PartnerSalesMetaSchema),
+		PartnerRedeem: mongoose.model("PartnerRedeem", PartnerRedeemSchema),
+		PartnerSalesHistory: mongoose.model("PartnerSalesHistory", PartnerSalesHistorySchema),
+		B2bRedeemOrder: mongoose.model("B2bRedeemOrder", B2bRedeemOrderSchema),
+		B2bRedeem: mongoose.model("B2bRedeem", B2bRedeemSchema),
+		B2bDealer: mongoose.model("B2bDealer", B2bDealerSchema),
+		OemRedeemPromotion: mongoose.model("OemRedeemPromotion", OemRedeemPromotionSchema)
+	};
+}
+//#endregion
+//#region src/models/payment.ts
+const log$5 = debug("model:payment");
+const OEM_FOCUSRITE_SUPPORT_LICENSE = [
+	{
+		support_type: {
+			product_name: "live",
+			type: "lite"
+		},
+		display_name: "LE"
+	},
+	{
+		support_type: {
+			product_name: "bias",
+			type: "lite"
+		},
+		display_name: "LE"
+	},
+	{
+		support_type: {
+			product_name: "amp2",
+			type: "lite"
+		},
+		display_name: "LE"
+	}
+];
+const OEM_APOGEE_SUPPORT_LICENSE = [{
+	support_type: {
+		product_name: "live",
+		type: "lite"
+	},
+	display_name: "BIAS FX JAM"
+}];
+const OEM_PROSONUS_SUPPORT_LICENSE = [{
+	support_type: {
+		product_name: "fx2",
+		type: "lite"
+	},
+	display_name: "BIAS FX 2 LE"
+}];
+function _oemMetaToLicenseName(redeemMeta) {
+	let ret;
+	switch (redeemMeta.OEM_Name) {
+		case "focusrite":
+			ret = _.find(OEM_FOCUSRITE_SUPPORT_LICENSE, (o) => isSubset(redeemMeta, o.support_type));
+			break;
+		case "Apogee":
+			ret = _.find(OEM_APOGEE_SUPPORT_LICENSE, (o) => isSubset(redeemMeta, o.support_type));
+			break;
+		case "ProSonus":
+			ret = _.find(OEM_PROSONUS_SUPPORT_LICENSE, (o) => isSubset(redeemMeta, o.support_type));
+			break;
+		default:
+			log$5("ERROR:_oemMetaToLicenseName %o", redeemMeta);
+			return null;
+	}
+	return !ret ? null : {
+		oem_name: redeemMeta.OEM_Name,
+		license_name: ret.display_name
+	};
+}
+function buildPayment(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const ProductSchema = new Schema({
+		sku: {
+			type: String,
+			required: true,
+			unique: true
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		display_name: {
+			type: String,
+			required: true
+		},
+		description: {
+			type: String,
+			required: true
+		},
+		price: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		product_type: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		quota: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		addition: {
+			type: Number,
+			required: true
+		},
+		version: {
+			type: String,
+			required: true
+		},
+		max_purchase: { type: Number },
+		can_upgrade_addition: { type: Boolean },
+		can_free_trial: {
+			type: Boolean,
+			default: false
+		},
+		upgrade: {
+			to: { type: ObjectId },
+			price: { type: Number },
+			description: { type: String }
+		},
+		upgrade_metadata: [{
+			to: { type: ObjectId },
+			price: { type: Number },
+			description: { type: String }
+		}],
+		discount: { type: Schema.Types.Mixed },
+		gift_list: {
+			type: [ObjectId],
+			default: () => null
+		},
+		require_list: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		require_one_list: [{
+			type: ObjectId,
+			ref: "Product"
+		}],
+		require_one_bundles: [{
+			type: ObjectId,
+			ref: "Bundle"
+		}],
+		free_upgrade_list: [{
+			has: { type: ObjectId },
+			to: { type: ObjectId }
+		}],
+		remap_product_sku: { type: String },
+		extra_payment_fields: { type: Schema.Types.Mixed },
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "jamup_product",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const LicenseSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		product_id: {
+			type: ObjectId,
+			ref: "Product",
+			required: true
+		},
+		bc_order_id: {
+			type: Number,
+			default: null
+		},
+		bc_coupon: {
+			type: [String],
+			default: () => null
+		},
+		quota: {
+			type: Number,
+			default: 0
+		},
+		from_redeem: {
+			type: String,
+			default: null
+		},
+		redeem_id: {
+			type: ObjectId,
+			ref: "RedeemCode"
+		},
+		from_bundle: {
+			type: ObjectId,
+			ref: "Bundle",
+			default: null
+		},
+		from_hardware: {
+			type: ObjectId,
+			ref: "hardware_activation_record",
+			default: null
+		},
+		from_gift: {
+			type: ObjectId,
+			ref: "License",
+			default: null
+		},
+		from_guest: {
+			type: ObjectId,
+			ref: "GuestCheckout",
+			default: null
+		},
+		from_remap: {
+			type: ObjectId,
+			ref: "Product"
+		},
+		from_free_trial: {
+			type: ObjectId,
+			ref: "FreeTrial",
+			default: null
+		},
+		upgrade_to: {
+			type: ObjectId,
+			ref: "License",
+			default: null
+		},
+		price_amount: {
+			type: Number,
+			default: null
+		},
+		due_date: {
+			type: Date,
+			default: null
+		},
+		iap_device_id: {
+			type: String,
+			default: null
+		},
+		iap_source: {
+			type: String,
+			default: null
+		},
+		metadata: {
+			type: String,
+			default: null
+		},
+		custom_metadata: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_license" });
+	LicenseSchema.index({
+		iap_device_id: 1,
+		user_id: 1,
+		product_id: 1,
+		status: 1
+	});
+	LicenseSchema.index({
+		user_id: 1,
+		product_id: 1,
+		status: 1,
+		iap_source: 1
+	});
+	LicenseSchema.index({
+		from_redeem: 1,
+		user_id: 1
+	});
+	LicenseSchema.index({
+		user_id: 1,
+		status: 1,
+		due_date: 1,
+		from_free_trial: 1
+	});
+	const trialTransform = (_doc, ret) => {
+		if (ret.from_free_trial && ret.from_free_trial !== null) ret.free_trial_meta = {
+			is_free_trial: true,
+			start_date: ret.created_on,
+			end_date: ret.due_date
+		};
+		else ret.free_trial_meta = null;
+		return ret;
+	};
+	LicenseSchema.set("toJSON", {
+		virtuals: true,
+		transform: trialTransform
+	});
+	LicenseSchema.set("toObject", {
+		virtuals: true,
+		transform: trialTransform
+	});
+	const LicenseUpgradeMetaSchema = new Schema({
+		bc_cart_id: {
+			type: String,
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		upgrade_from: {
+			type: ObjectId,
+			ref: "jamup_product",
+			default: null,
+			required: true
+		},
+		upgrade_to: {
+			type: ObjectId,
+			ref: "jamup_product",
+			default: null,
+			required: true
+		},
+		upgrade_bundle_from: [{
+			type: ObjectId,
+			ref: "jamup_product"
+		}],
+		upgrade_bundle_to: {
+			type: ObjectId,
+			ref: "jamup_bundle",
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 0
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "license_upgrade_meta" });
+	LicenseUpgradeMetaSchema.index({
+		bc_cart_id: 1,
+		user_id: 1,
+		upgrade_to: 1,
+		upgrade_from: 1
+	});
+	LicenseUpgradeMetaSchema.index({
+		bc_cart_id: 1,
+		user_id: 1,
+		upgrade_bundle_to: 1
+	});
+	LicenseUpgradeMetaSchema.static({
+		async saveUpgradeOrder(bcCartId, userId, upgradeFromProductId, upgradeToProductId) {
+			try {
+				return await this.findOneAndUpdate({
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_from: upgradeFromProductId,
+					upgrade_to: upgradeToProductId
+				}, { $set: {
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_from: upgradeFromProductId,
+					upgrade_to: upgradeToProductId,
+					status: 0,
+					created_on: /* @__PURE__ */ new Date()
+				} }, {
+					upsert: true,
+					new: true
+				}).exec();
+			} catch (err) {
+				log$5("ERR:saveUpgradeOrder:%o", err);
+				throw err;
+			}
+		},
+		async saveBundleUpgradeOrder(bcCartId, userId, userOwnedProductIds, upgradeToBundleId) {
+			try {
+				return await this.findOneAndUpdate({
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_bundle_to: upgradeToBundleId
+				}, { $set: {
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_bundle_to: upgradeToBundleId,
+					upgrade_bundle_from: userOwnedProductIds,
+					status: 0,
+					created_on: /* @__PURE__ */ new Date()
+				} }, {
+					upsert: true,
+					new: true
+				}).exec();
+			} catch (err) {
+				log$5("ERR:saveBundleUpgradeOrder:%o", err);
+				throw err;
+			}
+		},
+		async updateLicenseUpgradeStatusIfExist(bcCartId, userId, targetProductId) {
+			try {
+				const ret = await this.aggregate().match({
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_to: targetProductId
+				}).lookup({
+					from: "auth_user",
+					localField: "user_id",
+					foreignField: "_id",
+					as: "user"
+				}).unwind("user").lookup({
+					from: "jamup_product",
+					localField: "upgrade_from",
+					foreignField: "_id",
+					as: "from"
+				}).unwind("from").lookup({
+					from: "jamup_product",
+					localField: "upgrade_to",
+					foreignField: "_id",
+					as: "to"
+				}).unwind("to").exec();
+				if (ret.length === 1) {
+					await this.findOneAndUpdate({
+						bc_cart_id: bcCartId,
+						user_id: userId,
+						upgrade_to: targetProductId
+					}, { $set: { status: 1 } }).exec();
+					return ret[0];
+				}
+				return true;
+			} catch (err) {
+				log$5("ERR:updateLicenseUpgradeStatusIfExist:%o", err);
+				throw err;
+			}
+		},
+		async updateBundleUpgradeStatusIfExist(bcCartId, userId, targetBundleId) {
+			try {
+				if (await this.findOne({
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_bundle_to: targetBundleId
+				}).exec()) await this.findOneAndUpdate({
+					bc_cart_id: bcCartId,
+					user_id: userId,
+					upgrade_bundle_to: targetBundleId
+				}, { $set: { status: 1 } }).exec();
+				return true;
+			} catch (err) {
+				log$5("ERR:updateBundleUpgradeStatusIfExist:%o", err);
+				throw err;
+			}
+		}
+	});
+	const BundleSchema = new Schema({
+		name: {
+			type: String,
+			required: true
+		},
+		display_name: {
+			type: String,
+			required: true
+		},
+		display_detail: {
+			type: String,
+			default: null
+		},
+		description: {
+			type: Array,
+			required: true
+		},
+		price: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		sku: {
+			type: String,
+			default: null
+		},
+		products: [{
+			type: ObjectId,
+			ref: "Product"
+		}],
+		validate_list: [{
+			type: ObjectId,
+			ref: "Product"
+		}],
+		discount: { type: Schema.Types.Mixed },
+		partial_purchase: [{
+			product_id: { type: Schema.Types.Mixed },
+			exclude_product_ids: [{
+				type: ObjectId,
+				ref: "Product"
+			}],
+			discount_price: { type: Number },
+			discount_type: { type: String }
+		}],
+		require_list: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		require_one_list: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		extra_payment_fields: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "jamup_bundle",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const DiscountSchema = new Schema({
+		own_product: {
+			type: ObjectId,
+			ref: "Product",
+			required: true
+		},
+		discount_product: {
+			type: ObjectId,
+			ref: "Product"
+		},
+		discount_bundle: {
+			type: ObjectId,
+			ref: "Bundle"
+		},
+		discount_type: {
+			type: String,
+			required: true
+		},
+		discount_amount: {
+			type: Number,
+			required: true
+		},
+		start_date: {
+			type: Date,
+			default: null
+		},
+		end_date: {
+			type: Date,
+			default: null
+		},
+		status: {
+			type: Boolean,
+			default: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "jamup_discount",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	const EduDomainSchema = new Schema({
+		domain: {
+			type: String,
+			required: true
+		},
+		name: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1
+		}
+	}, { collection: "edu_domain" });
+	EduDomainSchema.index({ domain: 1 }, { unique: true });
+	const EduUserSchema = new Schema({
+		edu_domain_id: {
+			type: ObjectId,
+			ref: "edu_domain",
+			required: false
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		edu_email: {
+			type: String,
+			required: true
+		},
+		verify_token: {
+			type: String,
+			default: null
+		},
+		university_field: {
+			type: String,
+			default: null
+		},
+		coupon: {
+			type: String,
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "edu_user" });
+	const GuestCheckoutSchema = new Schema({
+		email: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		bc_order_id: {
+			type: Number,
+			default: null
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			default: null
+		},
+		purchased_items: [{
+			sku: {
+				type: String,
+				required: true
+			},
+			number: {
+				type: Number,
+				default: 1,
+				required: true
+			}
+		}],
+		store_code: { type: String },
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "pg_guest_checkout" });
+	GuestCheckoutSchema.index({
+		email: 1,
+		bc_order_id: 1
+	}, { unique: true });
+	const AdditionalPurchaseSchema = new Schema({
+		main_product_sku: [{
+			type: String,
+			required: true
+		}],
+		rule: {
+			type: String,
+			default: "has"
+		},
+		category: {
+			type: String,
+			default: null
+		},
+		multiplier: {
+			type: Number,
+			default: 1
+		},
+		additional_purchase: {
+			sku: {
+				type: String,
+				required: true
+			},
+			disount_type: {
+				type: String,
+				default: "amount"
+			},
+			disount_price: {
+				type: Number,
+				required: true
+			}
+		},
+		include_country: [{ type: String }],
+		exclude_country: [{ type: String }],
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "additional_purchase_meta" });
+	AdditionalPurchaseSchema.index({ main_product_sku: 1 });
+	AdditionalPurchaseSchema.index({ "additional_purchase.sku": 1 });
+	AdditionalPurchaseSchema.index({ include_country: 1 });
+	AdditionalPurchaseSchema.index({ exclude_country: 1 });
+	AdditionalPurchaseSchema.static({
+		async canPurchaseAdditional(ownedSku, additionalSku) {
+			if (!_.isArray(ownedSku) || !_.isArray(additionalSku)) throw new Error("Invalid parameter format!");
+			const additionalPurchaseData = await this.find({
+				"additional_purchase.sku": { $in: additionalSku },
+				status: 1
+			}).exec();
+			if (additionalPurchaseData.length <= 0) return true;
+			let canPurchase = false;
+			_.forEach(additionalPurchaseData, (addition) => {
+				if (addition.rule === "has") {
+					if (_.difference(ownedSku, addition.main_product_sku).length < ownedSku.length) canPurchase = true;
+				}
+			});
+			return canPurchase;
+		},
+		async verifyAdditionalPurchase(skus) {
+			const hasAdditionalPurchase = await this.find({
+				"additional_purchase.sku": { $in: skus },
+				status: 1
+			}).lean().exec();
+			if (hasAdditionalPurchase.length <= 0) return true;
+			let hasFulfill = true;
+			_.forEach(hasAdditionalPurchase, (addition) => {
+				if (addition.rule === "has") {
+					const mainSkus = addition.main_product_sku;
+					if (_.difference(mainSkus, skus).length >= mainSkus.length) hasFulfill = false;
+				}
+			});
+			return hasFulfill;
+		}
+	});
+	const CnSalesMetaSchema = new Schema({
+		product_id: {
+			type: ObjectId,
+			ref: "Product",
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		price: {
+			type: Number,
+			required: true
+		},
+		discount: {
+			type: Number,
+			default: null
+		},
+		gift: {
+			type: [ObjectId],
+			default: () => null
+		},
+		date: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "cn_sales_meta" });
+	CnSalesMetaSchema.static({ async getAllSaleItems(query = {}) {
+		try {
+			const queryCondition = _.isObject(query) && _.isEmpty(query) ? { status: 1 } : query;
+			return await this.aggregate().match(queryCondition).lookup({
+				from: "jamup_product",
+				localField: "product_id",
+				foreignField: "_id",
+				as: "product"
+			}).unwind("$product").project({
+				project_id: 1,
+				price: 1,
+				discount: 1,
+				cn_price: { $cond: {
+					if: { $ne: ["$discount", null] },
+					then: { $multiply: ["$discount", 7] },
+					else: { $multiply: ["$price", 7] }
+				} },
+				date: 1,
+				product: {
+					_id: 1,
+					name: 1,
+					display_name: 1,
+					sku: 1
+				}
+			}).exec();
+		} catch (err) {
+			log$5("ERR:getAllSaleItems:%o", err);
+			throw err;
+		}
+	} });
+	const CnCouponSchema = new Schema({
+		code: {
+			type: String,
+			unique: true,
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: false
+		},
+		stripe_order_id: {
+			type: String,
+			required: false
+		},
+		multiple_use: {
+			type: Boolean,
+			required: false
+		},
+		value: {
+			type: Number,
+			required: function() {
+				return !this.ratio;
+			}
+		},
+		ratio: {
+			type: Number,
+			required: function() {
+				return !this.value;
+			}
+		},
+		type: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		expired_on: {
+			type: Date,
+			required: false
+		}
+	}, { collection: "cn_coupon" });
+	CnCouponSchema.static({
+		async createCoupon({ value, user }) {
+			const that = this;
+			const generateCnCouponCode = async () => {
+				const code = `PGCN${Math.random().toString(36).substring(2, 12).toUpperCase()}`;
+				if (await that.findOne({ code }).exec()) return generateCnCouponCode();
+				return code;
+			};
+			try {
+				if (!value) throw new Error("No value provided");
+				const code = await generateCnCouponCode();
+				return await that.create({
+					code,
+					user_id: user ? user._id : null,
+					value
+				});
+			} catch (err) {
+				log$5("ERR:CnCoupon:createCoupon:%o", err);
+				throw err;
+			}
+		},
+		async findCoupon(code) {
+			return this.findOne({
+				code,
+				stripe_order_id: { $exists: false },
+				$or: [
+					{ expired_on: { $gte: /* @__PURE__ */ new Date() } },
+					{ expired_on: null },
+					{ expired_on: { $exists: false } }
+				]
+			}).exec();
+		}
+	});
+	CnCouponSchema.method({
+		calculateFinalPrice(price) {
+			return this.value ? price - this.value : parseFloat(String(price * this.ratio)).toPrecision(4);
+		},
+		calculateDeducted(price) {
+			return this.value ? this.value : price - parseFloat(String(price * this.ratio));
+		},
+		async consumeCoupon({ orderId }) {
+			if (!this.multiple_use) {
+				this.stripe_order_id = orderId;
+				return this.save();
+			}
+		}
+	});
+	const BcCartUpdateStatusSchema = new Schema({
+		bc_cart_id: {
+			type: String,
+			required: true
+		},
+		cart_item_id: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "bc_cart_update_status" });
+	BcCartUpdateStatusSchema.static({
+		async initCartUpdate(cartId, itemId) {
+			return this.findOneAndUpdate({
+				bc_cart_id: cartId,
+				cart_item_id: itemId
+			}, { $set: {
+				bc_cart_id: cartId,
+				cart_item_id: itemId,
+				status: 1,
+				created_on: /* @__PURE__ */ new Date()
+			} }, {
+				upsert: true,
+				new: true
+			}).exec();
+		},
+		async finishCartUpdate(cartId, itemId) {
+			return this.findOneAndUpdate({
+				bc_cart_id: cartId,
+				cart_item_id: itemId
+			}, { $set: { status: 2 } }, { new: true }).exec();
+		},
+		async handleCartUpdateError(cartId, itemId) {
+			return this.findOneAndUpdate({
+				bc_cart_id: cartId,
+				cart_item_id: itemId
+			}, { $set: { status: 3 } }, { new: true }).exec();
+		}
+	});
+	const PgUserOrderSchema = new Schema({
+		orderId: {
+			type: Number,
+			required: true
+		},
+		customerId: { type: Number },
+		statusId: { type: Number },
+		country: { type: String },
+		totalPrice: { type: Number },
+		purchaseItems: [{
+			sku: { type: String },
+			name: { type: String },
+			quantity: { type: Number },
+			price: { type: Number }
+		}],
+		orderData: { type: Schema.Types.Mixed },
+		createdAt: {
+			type: Date,
+			default: Date.now
+		},
+		updatedAt: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_user_orders" });
+	PgUserOrderSchema.index({ orderId: 1 });
+	PgUserOrderSchema.index({
+		statusId: 1,
+		"purchaseItems.sku": 1
+	});
+	ProductSchema.static({
+		getProductsByCondition(condition, cb) {
+			this.find(condition ?? {}).sort({ created_on: -1 }).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		createProduct(data, cb) {
+			this.create(data).then((p) => cb(null, p), (err) => cb(err));
+		}
+	});
+	LicenseSchema.static({
+		hasLicenseOrNot(userId, productId, cb) {
+			this.findOne({
+				user_id: userId,
+				product_id: productId,
+				status: 1
+			}).then((license) => {
+				if (license) return cb(/* @__PURE__ */ new Error("User already owned this license"));
+				return cb(null);
+			}, (err) => cb(err));
+		},
+		async hasLicensePromise(userID, productID) {
+			return await this.findOne({
+				user_id: userID,
+				product_id: productID,
+				status: 1,
+				$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+			}).exec();
+		},
+		getLicenseByRedeem(redeem, cb) {
+			this.find({ from_redeem: redeem }).sort({ created_on: -1 }).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		async getLicenseByRedeemPromise(redeem, userID) {
+			return this.find({
+				from_redeem: redeem,
+				user_id: new mongoose.Types.ObjectId(userID)
+			}).sort({ created_on: -1 }).populate("product_id").exec();
+		},
+		getUserLicense(query, cb) {
+			if (!_.isObject(query)) return cb(/* @__PURE__ */ new Error("Given query params should be a object"));
+			const queryObj = _.assign({}, query, {
+				status: { $in: [1, 4] },
+				$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+			});
+			this.find(queryObj).sort({ created_on: -1 }).populate("product_id", "id name price product_type status version addition extra_payment_fields").then((licenses) => {
+				if (!Array.isArray(licenses)) return cb(/* @__PURE__ */ new Error("Invalid data format"));
+				const result = [];
+				licenses.forEach((item) => {
+					if (item.product_id) result.push(item);
+				});
+				return cb(null, result);
+			}, (err) => cb(err));
+		},
+		async getUserLicensePromise(query) {
+			if (!_.isObject(query)) throw new Error("Given query params should be a object");
+			const queryObj = _.assign({}, query, {
+				status: { $in: [1, 4] },
+				$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+			});
+			const licenseData = await this.find(queryObj).sort({ created_on: -1 }).populate("product_id", "id name price product_type status version addition extra_payment_fields").exec();
+			if (!_.isArray(licenseData)) throw new Error("Invalid license data");
+			const result = [];
+			licenseData.forEach((item) => {
+				if (item.product_id) result.push(item);
+			});
+			return result;
+		},
+		getUserPurchase(query, productType, cb) {
+			if (!_.isObject(query)) return cb(/* @__PURE__ */ new Error("Given query params should be a object"));
+			const populateProductList = productType === "pack" ? "id name product_type display_name extra_payment_fields created_on" : "id name price product_type display_name status version addition";
+			const queryObj = _.assign({}, query, {
+				status: { $in: [1, 4] },
+				$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+			});
+			this.find(queryObj).sort({ created_on: -1 }).populate("product_id", populateProductList).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		async getUserPurchasePromise(query, productType, opts) {
+			if (!_.isObject(query)) throw new Error("Given query params should be a object");
+			const populateProductList = productType === "pack" ? "id name sku product_type display_name extra_payment_fields created_on" : "id name sku product_type display_name addition created_on";
+			const freeTrialQuery = productType === "free_trial" ? { $and: [{ from_free_trial: { $ne: null } }, { from_free_trial: { $exists: true } }] } : { $or: [{ from_free_trial: null }, { from_free_trial: { $exists: false } }] };
+			const queryObj = _.assign({}, {
+				status: { $in: [1, 4] },
+				$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+			}, freeTrialQuery, query);
+			if (_.has(opts, "isLean") && opts.isLean === true) return this.find(queryObj).sort({ created_on: -1 }).populate("product_id", populateProductList).lean({ virtuals: true }).exec();
+			return this.find(queryObj).sort({ created_on: -1 }).populate("product_id", populateProductList).exec();
+		},
+		async getUserIapLicenses(userId, iapIds) {
+			try {
+				return this.aggregate([
+					{ $match: {
+						user_id: userId,
+						product_id: { $in: iapIds },
+						status: 1,
+						$or: [{ due_date: null }, { due_date: { $gt: /* @__PURE__ */ new Date() } }]
+					} },
+					{ $lookup: {
+						from: "jamup_product",
+						localField: "product_id",
+						foreignField: "_id",
+						as: "product"
+					} },
+					{ $unwind: "$product" },
+					{ $project: {
+						main_product: "$product.extra_payment_fields.main_product",
+						iap_id: "$product.extra_payment_fields.iap_id",
+						category: "$product.extra_payment_fields.category",
+						display_name: "$product.display_name",
+						user_id: "$user_id",
+						source: "$iap_source",
+						created_on: "$created_on"
+					} }
+				]).exec();
+			} catch (err) {
+				log$5("ERR:getUserIapLicenses %o", err);
+				throw err;
+			}
+		},
+		async createTrialLicense(data) {
+			try {
+				if (!_.has(data, "due_date") || !moment(data.due_date).isValid()) throw new Error("Invalid trail license format!");
+				return await this.create(_.assign({}, data, {
+					status: 4,
+					due_date: moment(data.due_date).toDate()
+				}));
+			} catch (err) {
+				log$5("ERR:createTrialLicense:%o", err);
+				throw err;
+			}
+		},
+		createLicense(data, cb) {
+			const that = this;
+			that.create(data).then((license) => {
+				that.findById(license.id).populate("product_id").then((doc) => cb(null, doc), (err) => cb(err));
+			}, (err) => cb(err));
+		},
+		async createLicensePromise(data) {
+			try {
+				const newLicense = await this.create(data);
+				return await this.findById(newLicense.id).populate("product_id").exec();
+			} catch (err) {
+				log$5("ERR:createLicensePromise:%o", err);
+				throw err;
+			}
+		},
+		async removeLicense(licenseID) {
+			return await this.findOneAndUpdate({ _id: licenseID }, { $set: { status: 2 } }, { new: true }).exec();
+		}
+	});
+	ProductSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	LicenseSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	LicenseSchema.virtual("product").get(function() {
+		return this.product_id;
+	});
+	LicenseSchema.virtual("oem").get(function() {
+		return this.custom_metadata && this.custom_metadata.OEM_Name ? _oemMetaToLicenseName(this.custom_metadata) : null;
+	});
+	BundleSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	DiscountSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	LicenseSchema.plugin(mongooseLeanVirtuals);
+	return {
+		Product: mongoose.model("Product", ProductSchema),
+		License: mongoose.model("License", LicenseSchema),
+		LicenseUpgradeMeta: mongoose.model("LicenseUpgradeMeta", LicenseUpgradeMetaSchema),
+		Bundle: mongoose.model("Bundle", BundleSchema),
+		Discount: mongoose.model("Discount", DiscountSchema),
+		EduDomain: mongoose.model("EduDomain", EduDomainSchema),
+		EduUser: mongoose.model("EduUser", EduUserSchema),
+		GuestCheckout: mongoose.model("GuestCheckout", GuestCheckoutSchema),
+		CnCoupon: mongoose.model("CnCoupon", CnCouponSchema),
+		CnSalesMeta: mongoose.model("CnSalesMeta", CnSalesMetaSchema),
+		AdditionalPurchase: mongoose.model("AdditionalPurchase", AdditionalPurchaseSchema),
+		BcCartUpdateStatus: mongoose.model("BcCartUpdateStatus", BcCartUpdateStatusSchema),
+		UserOrder: mongoose.model("UserOrder", PgUserOrderSchema)
+	};
+}
+//#endregion
+//#region src/models/pgConfig.ts
+function buildPgConfig(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const PgConfigSchema = new Schema({
+		config_key: {
+			type: String,
+			index: { unique: true },
+			required: true
+		},
+		config_value: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_positivegridconfig" });
+	const PgLoggingSchema = new Schema({
+		type: {
+			type: String,
+			required: true
+		},
+		log_id: {
+			type: String,
+			required: true
+		},
+		log_content: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "User"
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_logging" });
+	PgLoggingSchema.index({
+		type: 1,
+		log_id: 1
+	});
+	const KeyValueSchema = new Schema({
+		key: {
+			type: String,
+			required: true
+		},
+		value: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		expire_at: {
+			type: Date,
+			default: null
+		}
+	}, { collection: "pg_key_value" });
+	KeyValueSchema.index({ key: 1 });
+	KeyValueSchema.index({ expire_at: 1 }, { expireAfterSeconds: 0 });
+	const CrashDataSchema = new Schema({
+		product: {
+			type: String,
+			required: true
+		},
+		crash_data: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		email: {
+			type: String,
+			default: null
+		},
+		crash_file: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_crash_data" });
+	PgConfigSchema.static({
+		getConfigByKey(config_key, cb) {
+			this.findOne({ config_key }).then((doc) => cb(null, doc), (err) => cb(err));
+		},
+		createOrUpdateConfig(key, value, doMerge, cb) {
+			const that = this;
+			let realCb = cb;
+			let realMerge;
+			if (_.isFunction(doMerge)) realCb = doMerge;
+			else realMerge = doMerge;
+			that.findOne({ config_key: key }).then((config) => {
+				if (config) {
+					config.config_value = _.isBoolean(realMerge) && realMerge === true ? _.assign({}, config.config_value, value) : value;
+					config.created_on = /* @__PURE__ */ new Date();
+					config.save().then((saved) => realCb(null, saved), (err) => realCb(err));
+				} else that.create({
+					config_key: key,
+					config_value: value
+				}).then((created) => realCb(null, created), (err) => realCb(err));
+			}, (err) => realCb(err));
+		},
+		deleteConfig(key, cb) {
+			this.findOneAndDelete({ config_key: key }).then((doc) => {
+				if (!doc) return cb(/* @__PURE__ */ new Error(`Cannot find config key ${key}`));
+				return cb(null, doc);
+			}, (err) => cb(err));
+		}
+	});
+	return {
+		PgConfig: mongoose.model("PgConfig", PgConfigSchema),
+		PgLogging: mongoose.model("PgLogging", PgLoggingSchema),
+		KeyValue: mongoose.model("KeyValue", KeyValueSchema),
+		CrashData: mongoose.model("CrashData", CrashDataSchema)
+	};
+}
+//#endregion
+//#region src/models/preset.ts
+const log$4 = debug("model:preset");
+function _queryCompatibilityHandler(query) {
+	let formatQuery = {};
+	if (_.has(query, "preset_for") && query.preset_for === "amp2") formatQuery = _.assign({}, query, { preset_for: { $in: ["amp2", "bias"] } });
+	else if (!_.has(query, "preset_for") || query.preset_for === "") formatQuery = _.assign({}, query, { preset_for: "jamup" });
+	if (_.isEmpty(formatQuery)) formatQuery = _.clone(query);
+	return formatQuery;
+}
+function _handlePresetVersion(queryObj, req) {
+	const supportVersionComparison = [
+		"eq",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"ne"
+	];
+	if (!_.has(req.query, "preset_for") || _.has(req.query, "preset_for") && req.query.preset_for !== "live") return _.clone(queryObj);
+	else if (_.has(req.query, "preset_version") && _.has(req.query, "version_comparison")) {
+		if (_.indexOf(supportVersionComparison, req.query.version_comparison) !== -1) {
+			const tmpVersionQuery = _.clone(queryObj);
+			const versionQuery = _buildPresetVersionQuery(req.query.preset_version, req.query.version_comparison);
+			if (versionQuery) return _.merge(tmpVersionQuery, versionQuery);
+		}
+	}
+	return _.clone(queryObj);
+}
+function _buildPresetVersionQuery(version, comparison) {
+	const tmpAttrs = String(version).split(".");
+	if (tmpAttrs.length !== 2) return false;
+	const major = parseInt(tmpAttrs[0], 10);
+	const minor = parseInt(tmpAttrs[1], 10);
+	switch (comparison) {
+		case "eq": return { $and: [{ "version.major": major }, { "version.minor": minor }] };
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": {
+			const compareOper = `$${comparison}`;
+			const minorQuery = {};
+			minorQuery[compareOper] = minor;
+			return { $and: [{ "version.major": major }, { "version.minor": minorQuery }] };
+		}
+		default: return false;
+	}
+}
+function _buildSortQuery(orderParam) {
+	switch (orderParam) {
+		case "popular": return { num_likes: -1 };
+		case "alphabet": return { name: 1 };
+		case "hot": return { num_downloads: -1 };
+		default: return { created_on: -1 };
+	}
+}
+function _buildLicenseTierQuery(licenseTierParam) {
+	const tmpLicenseTier = String(licenseTierParam).split(",");
+	const tmpData = /* @__PURE__ */ new Set();
+	const expansionData = /* @__PURE__ */ new Set();
+	const allExpansion = new Set(["celestion", "classic"]);
+	_.forEach(tmpLicenseTier, (lic) => {
+		switch (lic) {
+			case "celestion":
+			case "classic":
+				expansionData.add(lic);
+				allExpansion.delete(lic);
+				break;
+			case "elite":
+				tmpData.add("elite");
+				tmpData.add("pro");
+				tmpData.add("std");
+				tmpData.add(null);
+				break;
+			case "pro":
+				tmpData.add("pro");
+				tmpData.add("std");
+				tmpData.add(null);
+				break;
+			case "std":
+				tmpData.add("std");
+				tmpData.add(null);
+				break;
+			case "lite":
+			case "demo":
+				tmpData.add(null);
+				break;
+			default: break;
+		}
+	});
+	return expansionData.size > 0 ? { $and: [
+		{ license_tier: { $in: Array.from(tmpData) } },
+		{ license_tier: { $in: _.concat(Array.from(tmpData), Array.from(expansionData)) } },
+		{ license_tier: { $nin: Array.from(allExpansion) } }
+	] } : { $and: [{ license_tier: { $in: Array.from(tmpData) } }, { license_tier: { $nin: Array.from(allExpansion) } }] };
+}
+function _parsePageParams(data) {
+	let pageParams = {
+		page_size: 12,
+		page: 1
+	};
+	if (data && _.has(data, "page_size")) {
+		const pageSize = Array.isArray(data.page_size) ? parseInt(data.page_size.pop(), 10) : parseInt(data.page_size, 10);
+		if (pageSize >= 1) pageParams = _.merge(pageParams, { page_size: pageSize });
+	}
+	if (data && _.has(data, "page")) {
+		const page = Array.isArray(data.page) ? parseInt(data.page.pop(), 10) : parseInt(data.page, 10);
+		if (page > 1) pageParams = _.merge(pageParams, { page });
+	}
+	return pageParams;
+}
+function _filterKeyword(keyword) {
+	return String(keyword).replace(/[/\\@%&]+/g, "");
+}
+function buildPreset(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const deepPopulate = deepPopulateFactory(mongoose);
+	const PresetSchema = new Schema({
+		name: {
+			type: String,
+			index: true,
+			required: true
+		},
+		creator_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		preset_for: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		description: { type: String },
+		tags: {
+			type: [{ type: String }],
+			default: () => null
+		},
+		is_featured: {
+			type: Boolean,
+			default: false
+		},
+		category: {
+			type: String,
+			index: true
+		},
+		active_effects: { type: String },
+		preset_data: { type: String },
+		preset_features: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		version: {
+			major: { type: Number },
+			minor: { type: Number }
+		},
+		preset_meta: { type: Schema.Types.Mixed },
+		preset_scene: { type: Array },
+		license_tier: {
+			type: [{ type: String }],
+			index: true,
+			default: () => null
+		},
+		num_comments: {
+			type: Number,
+			default: 0
+		},
+		num_downloads: {
+			type: Number,
+			default: 0
+		},
+		num_likes: {
+			type: Number,
+			default: 0
+		},
+		rating_sum: {
+			type: Number,
+			default: 0
+		},
+		rating_avg: {
+			type: Number,
+			default: 0
+		},
+		rating_count: {
+			type: Number,
+			default: 0
+		},
+		image_url: { type: String },
+		thumb_url: { type: String },
+		signal_chain_type: {
+			type: String,
+			enum: ["in1", "in2"]
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "jamup_preset",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	PresetSchema.index({
+		name: 1,
+		description: 1,
+		category: 1
+	});
+	PresetSchema.index({
+		preset_for: 1,
+		status: 1
+	});
+	PresetSchema.index({
+		preset_for: 1,
+		signal_chain_type: 1,
+		status: 1
+	});
+	const PresetSongMappingSchema = new Schema({
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		song_id: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "preset_song_mapping" });
+	PresetSongMappingSchema.index({ song_id: 1 });
+	PresetSongMappingSchema.index({
+		preset_id: 1,
+		song_id: 1
+	}, { unique: true });
+	const PresetTagsMetaSchema = new Schema({
+		name: {
+			type: String,
+			required: true
+		},
+		count: {
+			type: Number,
+			default: 0,
+			required: true
+		},
+		preset_for: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "preset_tags_meta" });
+	PresetTagsMetaSchema.index({
+		name: 1,
+		preset_for: 1
+	}, { unique: true });
+	PresetTagsMetaSchema.index({ count: -1 });
+	const PresetUserComment = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		comment_text: {
+			type: String,
+			required: true
+		},
+		preset_for: { type: String },
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		date_comment: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_userpresetcomment" });
+	const PresetUserLike = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		preset_for: { type: String },
+		date_like: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_userpresetlike" });
+	const FakePresetLikeSchema = new Schema({
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		likes: {
+			type: Number,
+			default: 0
+		}
+	}, { collection: "fake_userpresetlike" });
+	const PresetUserDownload = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		preset_id: {
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		},
+		preset_for: {
+			type: String,
+			reqired: true
+		},
+		date_download: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "jamup_userpresetdownload" });
+	const PopularPresetList = new Schema({
+		preset_for: {
+			type: String,
+			required: true
+		},
+		popular_range: {
+			type: String,
+			required: true
+		},
+		popular_preset_list: [{
+			type: ObjectId,
+			ref: "Preset",
+			required: true
+		}],
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "jamup_popularpresetlist" });
+	PresetSchema.plugin(deepPopulate, {});
+	PresetUserLike.plugin(deepPopulate, {});
+	PresetUserComment.plugin(deepPopulate, {});
+	PresetSchema.static({
+		getPresetByUserId(userId, cb) {
+			this.find({ creator_id: userId }).sort({ created_on: -1 }).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		async getPresetByQuery(req, opts = {}) {
+			if (!_.has(req.query, "keyword") || !_.isString(req.query.keyword)) throw new Error("missing the searching term");
+			const pageParams = _parsePageParams(req.query);
+			let searchCondition = {
+				preset_for: req.query.preset_for ? req.query.preset_for : "jamup",
+				status: 0
+			};
+			if (_.has(req.query, "license_tier")) searchCondition = _.merge(_.clone(searchCondition), _buildLicenseTierQuery(req.query.license_tier));
+			if (_.has(req.query, "order") && req.query.order === "hot") searchCondition = _.assign({}, searchCondition, { created_on: { $gte: moment().subtract(1, "month").toDate() } });
+			searchCondition = _handlePresetVersion(searchCondition, req);
+			const aggregatePipeline = [
+				{ $search: {
+					index: "default",
+					compound: { should: [{ text: {
+						path: "name",
+						query: req.query.keyword,
+						fuzzy: {
+							maxEdits: 1,
+							prefixLength: 1,
+							maxExpansions: 30
+						},
+						score: { boost: { value: 3 } }
+					} }, { text: {
+						path: ["description", "category"],
+						query: req.query.keyword,
+						fuzzy: {
+							maxEdits: 2,
+							prefixLength: 0,
+							maxExpansions: 50
+						}
+					} }] }
+				} },
+				{ $match: searchCondition },
+				{ $skip: (pageParams.page - 1) * pageParams.page_size },
+				{ $limit: pageParams.page_size }
+			];
+			if (!_.has(opts, "full")) aggregatePipeline.push({ $project: { preset_data: 0 } });
+			return this.aggregate(aggregatePipeline);
+		},
+		async getPresetsBySearch(req) {
+			const pageParams = _parsePageParams(req.query);
+			const sortCondition = _buildSortQuery(req.query.order);
+			let searchCondition = {
+				preset_for: req.query.preset_for ? req.query.preset_for : "jamup",
+				status: 0
+			};
+			let selectOps = {};
+			if (!_.has(req.query, "detail") || req.query.detail !== "yes") selectOps = { preset_data: 0 };
+			if (_.has(req.query, "pids")) {
+				const pids = req.query.pids.split(",");
+				searchCondition._id = { $in: pids };
+			}
+			if (_.has(req.query, "category")) searchCondition.category = { $in: String(req.query.category).split(",") };
+			else if (_.has(req.query, "except_cateogry")) searchCondition.category = { $nin: String(req.query.except_cateogry).split(",") };
+			if (_.has(req.query, "pedal_type")) searchCondition["preset_meta.pedal_type"] = req.query.pedal_type;
+			if (_.has(req.query, "preset_features")) {
+				const params = req.query.preset_features.split(",");
+				const featureQuery = {};
+				_.forEach(params, (param) => {
+					const t = param.split(":");
+					if (t.length === 2) featureQuery[t[0]] = parseInt(t[1], 10);
+				});
+				searchCondition.preset_features = featureQuery;
+			}
+			const createQuery = {};
+			if (_.has(req.query, "create_after")) {
+				const d = moment(req.query.create_after);
+				if (d.isValid()) createQuery.$gte = d.toDate();
+			}
+			if (_.has(req.query, "create_before")) {
+				const d = moment(req.query.create_before);
+				if (d.isValid()) createQuery.$lte = d.toDate();
+			}
+			if (!_.isEmpty(createQuery)) searchCondition.created_on = createQuery;
+			const updateQuery = {};
+			if (_.has(req.query, "update_after")) {
+				const d = moment(req.query.update_after);
+				if (d.isValid()) updateQuery.$gte = d.toDate();
+			}
+			if (_.has(req.query, "update_before")) {
+				const d = moment(req.query.update_before);
+				if (d.isValid()) updateQuery.$lte = d.toDate();
+			}
+			if (!_.isEmpty(updateQuery)) searchCondition.updated_on = updateQuery;
+			if (_.has(req.query, "license_tier")) searchCondition = _.merge(_.clone(searchCondition), _buildLicenseTierQuery(req.query.license_tier));
+			if (_.has(req.query, "order") && req.query.order === "hot") searchCondition = _.assign({}, searchCondition, { created_on: { $gte: moment().subtract(1, "month").toDate() } });
+			if (searchCondition.preset_for === "spark") {
+				if (_.has(req.query, "signal_chain_type")) searchCondition.signal_chain_type = req.query.signal_chain_type;
+				if (_.has(req.query, "no_dspid")) searchCondition["preset_meta.dspId"] = { $nin: String(req.query.no_dspid).split(",") };
+			}
+			searchCondition = _handlePresetVersion(searchCondition, req);
+			if (_.has(req, "query.keyword") && !_.isEmpty(req.query.keyword)) {
+				if (_.has(process.env, "IS_CHINA")) {
+					searchCondition.$or = [{ name: new RegExp(`^${_filterKeyword(req.query.keyword)}`, "i") }, { description: new RegExp(`${_filterKeyword(req.query.keyword)}`, "i") }];
+					return this.aggregate([
+						{ $match: _queryCompatibilityHandler(searchCondition) },
+						{ $sort: sortCondition },
+						{ $project: selectOps },
+						{ $skip: (pageParams.page - 1) * pageParams.page_size },
+						{ $limit: pageParams.page_size },
+						{ $addFields: { id: "$_id" } }
+					]);
+				}
+				return this.aggregate([
+					{ $search: { text: {
+						path: ["name", "description"],
+						query: req.query.keyword
+					} } },
+					{ $match: _queryCompatibilityHandler(searchCondition) },
+					{ $sort: sortCondition },
+					{ $project: selectOps },
+					{ $skip: (pageParams.page - 1) * pageParams.page_size },
+					{ $limit: pageParams.page_size },
+					{ $addFields: { id: "$_id" } }
+				]);
+			}
+			return this.aggregate([
+				{ $match: _queryCompatibilityHandler(searchCondition) },
+				{ $sort: sortCondition },
+				{ $project: selectOps },
+				{ $skip: (pageParams.page - 1) * pageParams.page_size },
+				{ $limit: pageParams.page_size },
+				{ $addFields: { id: "$_id" } }
+			]);
+		},
+		getPresetsList(query, sort, req, cb) {
+			const pageParams = _parsePageParams(req.query);
+			let q = query;
+			if (_.isObject(q)) q.status = 0;
+			if (_.has(q, "preset_for") && q.preset_for !== "jamup") {
+				q.image_url = { $ne: null };
+				q.thumb_url = { $ne: null };
+			}
+			if (_.has(req.query, "license_tier")) q = _.merge(_.clone(q), _buildLicenseTierQuery(req.query.license_tier));
+			let finalSort = sort;
+			if (_.has(req.query, "order")) finalSort = _buildSortQuery(req.query.order);
+			q = _handlePresetVersion(q, req);
+			this.find(_queryCompatibilityHandler(q)).sort(finalSort).select("-preset_data").skip((pageParams.page - 1) * pageParams.page_size).limit(pageParams.page_size).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		getPresetsListPromise(query, sort, req) {
+			return new Promise((resolve, reject) => {
+				this.getPresetsList(query, sort, req, (err, likes) => err ? reject(err) : resolve(likes));
+			});
+		},
+		getMyPresets(query, sort, req, cb) {
+			const pageParams = _parsePageParams(req.query);
+			let q = query;
+			if (_.isObject(q)) q.status = { $in: [0, 2] };
+			if (_.has(q, "preset_for") && q.preset_for !== "jamup") {
+				q.image_url = { $ne: null };
+				q.thumb_url = { $ne: null };
+			}
+			q = _handlePresetVersion(q, req);
+			this.find(_queryCompatibilityHandler(q)).sort(sort).select("-preset_data").skip((pageParams.page - 1) * pageParams.page_size).limit(pageParams.page_size).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		getOnePresetByCondition(query, opts, cb) {
+			const defaultSort = _.has(opts, "sort") && _.isObject(opts.sort) ? opts.sort : { created_on: -1 };
+			const defaultSelect = _.has(opts, "select") && _.isString(opts.select) ? opts.select : "";
+			this.findOne(_queryCompatibilityHandler(query)).sort(defaultSort).select(defaultSelect).then((doc) => cb(null, doc), (err) => cb(err));
+		},
+		getSinglePreset(id, cb) {
+			this.findOne({
+				_id: id,
+				status: 0
+			}).then((d) => cb(null, d), (err) => cb(err));
+		},
+		getValidSinglePreset(id, cb) {
+			this.findOne({
+				_id: id,
+				status: { $in: [
+					0,
+					2,
+					3
+				] }
+			}).then((d) => cb(null, d), (err) => cb(err));
+		}
+	});
+	PresetUserComment.static({ async getPresetComments(presetId, req) {
+		try {
+			const pageParams = _parsePageParams(req.query);
+			return await this.aggregate([
+				{ $match: {
+					preset_id: new mongoose.Types.ObjectId(presetId),
+					status: 1
+				} },
+				{ $sort: { date_comment: -1 } },
+				{ $skip: (pageParams.page - 1) * pageParams.page_size },
+				{ $limit: pageParams.page_size },
+				{ $lookup: {
+					from: "auth_user",
+					localField: "user_id",
+					foreignField: "_id",
+					as: "tmpUser"
+				} },
+				{ $lookup: {
+					from: "jamup_userprofile",
+					localField: "user_id",
+					foreignField: "user_id",
+					as: "tmpProfile"
+				} },
+				{ $unwind: "$tmpUser" },
+				{ $unwind: "$tmpProfile" },
+				{ $project: {
+					preset_id: 1,
+					comment_text: 1,
+					date_comment: 1,
+					user: {
+						_id: "$tmpUser._id",
+						email: "$tmpUser.email",
+						date_joined: "$tmpUser.date_joined",
+						full_name: "$tmpProfile.full_name",
+						first_name: "$tmpProfile.first_name",
+						last_name: "$tmpProfile.last_name",
+						profile_image_url: "$tmpProfile.profile_image_url",
+						profile_thumb_url: "$tmpProfile.profile_thumb_url"
+					}
+				} }
+			]).exec();
+		} catch (err) {
+			log$4("ERR:getPresetComment:%o", err);
+			throw err;
+		}
+	} });
+	PresetUserLike.static({
+		getCountByPresetCondition(query, condition, cb) {
+			this.find(query).populate("preset_id").then((result) => {
+				return cb(null, _.filter(result, (item) => {
+					const tmpObj = item.toObject ? item.toObject() : item;
+					return _.has(tmpObj.preset_id, condition);
+				}).length);
+			}, (err) => cb(err));
+		},
+		getPresetLikeList(query, sort, req, cb) {
+			const pageParams = _parsePageParams(req.query);
+			const defaultPresetCondition = { "preset.status": { $eq: 0 } };
+			let filterQuery = {};
+			if (_.has(query, "no_dspid")) {
+				defaultPresetCondition["preset.preset_meta.dspId"] = { $nin: String(query.no_dspid).split(",") };
+				filterQuery = _.omit(query, ["no_dspid"]);
+			} else filterQuery = _.clone(query);
+			const aggregateQuery = [
+				{ $match: _.assign({}, _queryCompatibilityHandler(filterQuery), { user_id: new mongoose.Types.ObjectId(filterQuery.user_id) }) },
+				{ $lookup: {
+					from: "jamup_preset",
+					localField: "preset_id",
+					foreignField: "_id",
+					as: "preset"
+				} },
+				{ $unwind: "$preset" },
+				{ $match: defaultPresetCondition }
+			];
+			const presetQuery = _handlePresetVersion({}, req);
+			if (!_.isEmpty(presetQuery) && _.has(presetQuery, "$and") && _.isArray(presetQuery.$and)) _.forEach(presetQuery.$and, (item) => {
+				const newQuery = { $match: {} };
+				const objKey = _.keys(item);
+				const objVal = _.values(item);
+				if (objKey.length === 1 && objVal.length === 1) {
+					newQuery.$match[`preset.${objKey[0]}`] = objVal[0];
+					aggregateQuery.push(newQuery);
+				}
+			});
+			this.aggregate(aggregateQuery).sort({ date_like: -1 }).skip((pageParams.page - 1) * pageParams.page_size).limit(pageParams.page_size).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		getPresetLikeListPromise(query, sort, req) {
+			return new Promise((resolve, reject) => {
+				this.getPresetLikeList(query, sort, req, (err, likes) => err ? reject(err) : resolve(likes));
+			});
+		}
+	});
+	PresetSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	PresetSchema.virtual("preset_version").get(function() {
+		const v = this.version;
+		return v && Number.isInteger(v.major) && Number.isInteger(v.minor) ? `${v.major}.${v.minor}` : "1.0";
+	}).set(function(presetVersion) {
+		const versionDetail = presetVersion.split(".");
+		this.set("version.major", parseInt(versionDetail[0], 10));
+		this.set("version.minor", parseInt(versionDetail[1], 10));
+	});
+	return {
+		Preset: mongoose.model("Preset", PresetSchema),
+		PresetComment: mongoose.model("PresetComment", PresetUserComment),
+		PresetLike: mongoose.model("PresetLike", PresetUserLike),
+		PresetDownload: mongoose.model("PresetDownload", PresetUserDownload),
+		PopularPresetList: mongoose.model("PopularPresetList", PopularPresetList),
+		FakePresetLike: mongoose.model("FakePresetLike", FakePresetLikeSchema),
+		PresetTagsMeta: mongoose.model("PresetTagsMeta", PresetTagsMetaSchema),
+		PresetSongMapping: mongoose.model("PresetSongMapping", PresetSongMappingSchema)
+	};
+}
+//#endregion
+//#region src/models/promotion.ts
+const log$3 = debug("model:promotion");
+const CAMPAIGN_TYPE = ["free_upgrade"];
+function buildPromotion(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const LicenseCampaignMetaSchema = new Schema({
+		campaign_type: {
+			type: String,
+			enum: CAMPAIGN_TYPE,
+			required: true
+		},
+		campaign_detail: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		start_date: {
+			type: Date,
+			default: null
+		},
+		end_date: {
+			type: Date,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "license_campaign_meta" });
+	const LicenseCampaignRecordSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		campaign_event_id: {
+			type: ObjectId,
+			ref: "license_campaign_meta",
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "license_campaign_record" });
+	const PublicAnnouncementSchema = new Schema({
+		title: {
+			type: String,
+			required: true
+		},
+		content: {
+			type: String,
+			required: true
+		},
+		type: {
+			type: String,
+			enum: ["announcement", "freetrial"]
+		},
+		country: [{ type: String }],
+		image: {
+			type: String,
+			default: null
+		},
+		image_type: { type: String },
+		message_type: { type: String },
+		action_button: [{
+			type: {
+				type: String,
+				required: true
+			},
+			text: {
+				type: String,
+				required: true
+			},
+			value: { type: Schema.Types.Mixed },
+			read: {
+				type: Boolean,
+				required: true
+			}
+		}],
+		show_countdown: {
+			type: Boolean,
+			default: false,
+			required: true
+		},
+		announce_for: [{
+			type: String,
+			required: true
+		}],
+		target_audience_device: [{
+			type: String,
+			required: true
+		}],
+		device_os: { type: String },
+		device_list: [{ type: String }],
+		announce_license_tier: [{
+			type: String,
+			required: true
+		}],
+		announce_mobile_iap: [{
+			type: String,
+			required: true
+		}],
+		user_list_num: {
+			type: Number,
+			default: 0
+		},
+		user_list_status: {
+			type: Number,
+			default: 0
+		},
+		user_list_failure: {
+			type: Number,
+			default: 0
+		},
+		user_list_log: {
+			type: String,
+			default: null
+		},
+		user_list_filename: {
+			type: String,
+			default: null
+		},
+		start_time: {
+			type: Date,
+			default: null
+		},
+		end_time: {
+			type: Date,
+			default: null
+		},
+		locale: {
+			type: String,
+			required: true
+		},
+		order: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "public_announcement" });
+	PublicAnnouncementSchema.static({ async getAvailableAnnouncement(params) {
+		try {
+			const nowTime = /* @__PURE__ */ new Date();
+			const defaultQuery = { $and: [{ $or: [{ start_time: null }, { start_time: { $lt: nowTime } }] }, { $or: [{ end_time: null }, { end_time: { $gt: nowTime } }] }] };
+			if (!_.isUndefined(params)) {
+				log$3("getAvailableAnnouncement:querystring %o", params);
+				const { pname, locale, ta_device, country, device_list, device_os } = params;
+				if (!_.isUndefined(pname) && _.isString(pname)) defaultQuery.$and.push({ announce_for: { $in: _.concat([pname], "all") } });
+				if (!_.isUndefined(locale) && _.isString(locale)) defaultQuery.$and.push({ locale });
+				if (!_.isUndefined(ta_device) && _.isString(ta_device)) defaultQuery.$and.push({ target_audience_device: { $in: _.concat(ta_device.split(","), "all") } });
+				if (!_.isUndefined(country) && _.isString(country)) defaultQuery.$and.push({ $or: [{ country: { $all: country.split(",") } }, { country: { $in: ["all"] } }] });
+				else defaultQuery.$and.push({ $or: [{ country: { $in: ["all"] } }, { country: { $exists: false } }] });
+				if (!_.isUndefined(device_list)) if (_.isString(device_list) && !_.isEmpty(device_list)) {
+					const tmpDeviceList = device_list.split(",");
+					const deviceList = [];
+					const allTypeSet = /* @__PURE__ */ new Set();
+					const uniqueProductLineSet = /* @__PURE__ */ new Set();
+					tmpDeviceList.forEach((deviceItem) => {
+						const optionItem = deviceItem.split("_");
+						uniqueProductLineSet.add(optionItem[0]);
+						if (optionItem.length === 2 && optionItem[1] === "all") allTypeSet.add(optionItem[0]);
+						else deviceList.push(deviceItem);
+					});
+					if (allTypeSet.size > 0) allTypeSet.forEach((item) => deviceList.push(new RegExp(`^${item}_`)));
+					if (uniqueProductLineSet.size > 0) uniqueProductLineSet.forEach((item) => deviceList.push(`${item}_all`));
+					defaultQuery.$and.push({ device_list: { $in: deviceList } });
+				} else defaultQuery.$and.push({ device_list: { $in: ["none"] } });
+				if (!_.isUndefined(device_os) && _.isString(device_os)) defaultQuery.$and.push({ $or: [{ device_os: "all" }, { device_os }] });
+			}
+			let ret;
+			if (!_.has(params, "email") || _.has(params, "email") && _.isUndefined(params.email)) {
+				defaultQuery.$and.push({ user_list_num: 0 });
+				defaultQuery.$and.push({ action_button: { $elemMatch: { type: { $ne: "free_trial" } } } });
+				ret = await this.find(defaultQuery).lean().exec();
+			} else {
+				const noUserQuery = _.cloneDeep(defaultQuery);
+				noUserQuery.$and.push({ user_list_num: 0 });
+				const hasUserQuery = _.cloneDeep(defaultQuery);
+				hasUserQuery.$and.push({ user_list_num: { $gt: 0 } });
+				const [noUserData, hasUserData] = await Promise.all([this.aggregate([{ $match: noUserQuery }]).exec(), this.aggregate([
+					{ $match: hasUserQuery },
+					{ $lookup: {
+						from: "public_announcement_userlist",
+						localField: "_id",
+						foreignField: "pa_id",
+						as: "paUserList"
+					} },
+					{ $unwind: "$paUserList" },
+					{ $match: {
+						"paUserList.email": String(params.email).toLowerCase(),
+						"paUserList.status": 1
+					} }
+				]).exec()]);
+				ret = _.concat(noUserData, hasUserData);
+			}
+			return _.orderBy(ret, ["order", "start_time"], ["desc", "asc"]);
+		} catch (err) {
+			log$3("ERR:getAvailableAnnouncement %j", err);
+			throw err;
+		}
+	} });
+	const PublicAnnouncementFreeTrialSchema = new Schema({
+		pa_id: {
+			type: ObjectId,
+			ref: "PublicAnnouncement",
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		product_id: {
+			type: ObjectId,
+			ref: "Product",
+			default: null
+		},
+		expansion_id: {
+			type: ObjectId,
+			ref: "Product",
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		expire_on: {
+			type: Date,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "public_announcement_free_trial" });
+	PublicAnnouncementFreeTrialSchema.index({
+		pa_id: 1,
+		user_id: 1,
+		product_id: 1,
+		expansion_id: 1
+	}, { unique: true });
+	PublicAnnouncementFreeTrialSchema.static({ async getCurrentActiveFreeTrial(params) {
+		try {
+			const { userId } = params;
+			if (!userId) throw new Error("Missing userId");
+			const nowTime = /* @__PURE__ */ new Date();
+			return await this.aggregate([
+				{ $match: { user_id: new mongoose.Types.ObjectId(userId) } },
+				{ $lookup: {
+					from: "public_announcement",
+					localField: "pa_id",
+					foreignField: "_id",
+					as: "pa"
+				} },
+				{ $unwind: {
+					path: "$pa",
+					preserveNullAndEmptyArrays: false
+				} },
+				{ $match: { $and: [{ $or: [{ "pa.start_time": null }, { "pa.start_time": { $lt: nowTime } }] }, { $or: [{ "pa.end_time": null }, { "pa.end_time": { $gt: nowTime } }] }] } }
+			]).exec();
+		} catch (err) {
+			log$3("ERR:getAvailableFreeTrial %o", err);
+			throw err;
+		}
+	} });
+	const PublicAnnouncementUserListSchema = new Schema({
+		pa_id: {
+			type: ObjectId,
+			ref: "PublicAnnouncement",
+			required: true
+		},
+		email: {
+			type: String,
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "User"
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "public_announcement_userlist" });
+	PublicAnnouncementUserListSchema.static({ async getAvailableAnnouncementByEmail(email) {
+		try {
+			const nowTime = /* @__PURE__ */ new Date();
+			return this.aggregate([
+				{ $match: {
+					email: String(email).toLowerCase(),
+					status: 1
+				} },
+				{ $lookup: {
+					from: "public_announcement",
+					localField: "pa_id",
+					foreignField: "_id",
+					as: "pa"
+				} },
+				{ $unwind: "$pa" },
+				{ $match: { $and: [
+					{ $or: [{ "pa.start_time": null }, { "pa.start_time": { $lt: nowTime } }] },
+					{ $or: [{ "pa.end_time": null }, { "pa.end_time": { $gt: nowTime } }] },
+					{ "pa.user_list_num": { $gt: 0 } }
+				] } }
+			]).exec();
+		} catch (err) {
+			log$3("ERR:getAnnouncementFromUserList:%o", err);
+			throw err;
+		}
+	} });
+	const PublicAnnouncementUserListLog = new Schema({
+		pa_id: {
+			type: ObjectId,
+			ref: "PublicAnnouncement",
+			required: true
+		},
+		message: { type: Schema.Types.Mixed }
+	}, { collection: "public_announcement_userlist_log" });
+	const IasBuyOptionSchema = new Schema({
+		type: {
+			type: String,
+			required: true
+		},
+		sku: {
+			type: String,
+			required: true
+		},
+		description: {
+			type: String,
+			required: true
+		},
+		cta_name: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		locale: {
+			type: String,
+			required: true
+		}
+	}, { collection: "ias_buy_option" });
+	const IasStorePageMetaSchema = new Schema({
+		product: {
+			type: String,
+			required: true
+		},
+		expansion: {
+			type: Boolean,
+			default: false
+		},
+		license: {
+			type: String,
+			required: true
+		},
+		buy_option: [{
+			type: ObjectId,
+			ref: "IasBuyOption",
+			required: true
+		}],
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		promotion_target_audiance: {
+			type: String,
+			required: true
+		},
+		promotion_discount: {
+			type: String,
+			required: true
+		},
+		product_description: {
+			type: String,
+			required: true
+		},
+		quote_image: {
+			type: String,
+			required: true
+		},
+		locale: {
+			type: String,
+			required: true
+		},
+		cta_image: { type: String },
+		cta_button_text: { type: String },
+		cta_button_show_svg: { type: Boolean },
+		cta_button_action_url: { type: String }
+	}, { collection: "ias_store_page_meta" });
+	const IasPromotionSchema = new Schema({
+		start_time: {
+			type: Date,
+			required: true
+		},
+		end_time: {
+			type: Date,
+			required: true
+		},
+		quote_image: {
+			type: String,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "ias_promotion" });
+	const SpecialOfferSchema = new Schema({
+		title: {
+			type: String,
+			required: true
+		},
+		content: {
+			type: String,
+			required: true
+		},
+		image: {
+			type: String,
+			default: null
+		},
+		action_button: [{
+			type: {
+				type: String,
+				required: true
+			},
+			text: {
+				type: String,
+				required: true
+			},
+			value: { type: Schema.Types.Mixed },
+			read: {
+				type: Boolean,
+				required: true
+			}
+		}],
+		announce_for: [{
+			type: String,
+			required: true
+		}],
+		target_audience_device: [{
+			type: String,
+			required: true
+		}],
+		start_time: {
+			type: Date,
+			default: null
+		},
+		end_time: {
+			type: Date,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		locale: {
+			type: String,
+			required: true
+		}
+	}, { collection: "special_offer" });
+	const PromotionSchema = new Schema({
+		name: {
+			type: String,
+			required: true
+		},
+		start_date: {
+			type: Date,
+			required: true
+		},
+		end_date: {
+			type: Date,
+			required: true
+		},
+		items: [{
+			sku: {
+				type: String,
+				required: true
+			},
+			sale_price: {
+				type: Number,
+				required: true
+			},
+			price: {
+				type: Number,
+				required: true
+			},
+			name: {
+				type: String,
+				required: true
+			}
+		}]
+	}, { collection: "promotion" });
+	const CampaignUserInfoSchema = new Schema({
+		campaign: {
+			type: String,
+			required: true
+		},
+		email: {
+			type: String,
+			required: true
+		},
+		name: { type: String },
+		redeem: { type: String },
+		metadata: { type: Schema.Types.Mixed },
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "campaign_user_info" });
+	CampaignUserInfoSchema.index({ campaign: 1 });
+	CampaignUserInfoSchema.index({
+		campaign: 1,
+		email: 1
+	}, { unique: true });
+	CampaignUserInfoSchema.index({
+		campaign: 1,
+		email: 1,
+		redeem: 1
+	});
+	const CouponPromotionSchema = new Schema({
+		email: {
+			type: String,
+			required: true
+		},
+		code: {
+			type: String,
+			required: true
+		},
+		referral: { type: String },
+		event: { type: String },
+		type: { type: String },
+		metadata: { type: Schema.Types.Mixed },
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "coupon_promotion" });
+	CouponPromotionSchema.index({
+		email: 1,
+		event: 1
+	});
+	CouponPromotionSchema.index({
+		email: 1,
+		event: 1,
+		referral: 1
+	}, { unique: true });
+	const TierSalesMetaSchema = new Schema({
+		campaign_key: {
+			type: String,
+			required: true
+		},
+		current_tier_sales_rule: {
+			type: ObjectId,
+			ref: "TierSalesRules"
+		},
+		current_tier_startdate: {
+			type: Date,
+			default: null
+		},
+		process_log: [{
+			from_tier_id: {
+				type: ObjectId,
+				ref: "TierSalesRules",
+				required: true
+			},
+			to_tier_id: {
+				type: ObjectId,
+				ref: "TierSalesRules",
+				required: true
+			},
+			updated_on: {
+				type: Date,
+				required: true
+			}
+		}],
+		status: {
+			type: Number,
+			default: 1
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "tier_sales_meta" });
+	const TierSalesRulesSchema = new Schema({
+		campaign_key: {
+			type: String,
+			required: true
+		},
+		tier_level: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		tier_type: {
+			type: Number,
+			default: 0
+		},
+		pre_rule_id: {
+			type: ObjectId,
+			ref: "TierSalesRules"
+		},
+		price: {
+			type: Number,
+			required: true
+		},
+		ta_sku: {
+			type: String,
+			required: true
+		},
+		next_sku: {
+			type: String,
+			default: null
+		},
+		goal: [{
+			type: { type: String },
+			value: { type: Number }
+		}],
+		force_switch_tier: {
+			type: Date,
+			default: null
+		},
+		is_final_tier: {
+			type: Boolean,
+			default: false
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "tier_sales_rules" });
+	const GearTrialMetaSchema = new Schema({
+		title: {
+			type: String,
+			required: true
+		},
+		announce_for: [{
+			type: String,
+			required: true
+		}],
+		target_audience_device: [{
+			type: String,
+			required: true
+		}],
+		locale: {
+			type: String,
+			required: true
+		},
+		target_product_sku: [{
+			type: String,
+			required: true
+		}],
+		expires: {
+			type: Number,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "gear_trial_meta" });
+	GearTrialMetaSchema.index({ status: 1 });
+	const GearTrialRecordSchema = new Schema({
+		gear_trial_id: {
+			type: ObjectId,
+			ref: "gear_trial_meta",
+			required: true
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		expire_on: {
+			type: Date,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "gear_trial_record" });
+	GearTrialRecordSchema.index({
+		gear_trial_id: 1,
+		user_id: 1
+	});
+	GearTrialRecordSchema.index({
+		user_id: 1,
+		expire_on: 1
+	});
+	const YotpoLoyaltySchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "auth_user",
+			required: true
+		},
+		main_region: {
+			type: String,
+			required: true
+		},
+		active_regions: [{
+			code: {
+				type: String,
+				required: true
+			},
+			points_balance: {
+				type: Number,
+				default: 0,
+				required: true
+			},
+			points_earned: {
+				type: Number,
+				default: 0,
+				required: true
+			}
+		}],
+		history: [{
+			created_at: {
+				type: String,
+				required: true
+			},
+			date: {
+				type: String,
+				required: true
+			},
+			completed_on: {
+				type: String,
+				default: null
+			},
+			action: {
+				type: String,
+				default: null
+			},
+			points: {
+				type: Number,
+				default: 0
+			},
+			status: {
+				type: String,
+				default: null
+			},
+			action_name: {
+				type: String,
+				default: null
+			},
+			order_ids: [{ type: String }]
+		}],
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "auth_yotpo_loyalty" });
+	YotpoLoyaltySchema.index({ user_id: 1 }, { unique: true });
+	YotpoLoyaltySchema.index({
+		user_id: 1,
+		main_region: 1,
+		"active_regions.code": 1
+	});
+	const YotpoLoyaltyBackupSchema = new Schema({
+		email: {
+			type: String,
+			required: true
+		},
+		store_code: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "yotpo_loyalty_backup" });
+	YotpoLoyaltyBackupSchema.index({
+		email: 1,
+		store_code: 1
+	}, { unique: true });
+	const FreeTrialSchema = new Schema({
+		campaign_name: {
+			type: String,
+			required: true
+		},
+		campaign_code: {
+			type: String,
+			required: true
+		},
+		content: {
+			type: String,
+			default: null
+		},
+		products: [{
+			type: ObjectId,
+			ref: "Product",
+			required: true
+		}],
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		start_time: {
+			type: Date,
+			required: true
+		},
+		end_time: {
+			type: Date,
+			required: true
+		},
+		trial_days: {
+			type: Number,
+			default: 0
+		},
+		not_allow_same_product: {
+			type: Boolean,
+			default: false
+		},
+		created_by: {
+			type: String,
+			default: null
+		},
+		terminate: {
+			reason: { type: String },
+			user: { type: String },
+			time: { type: Date }
+		},
+		metadata: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "free_trial_campaign" });
+	FreeTrialSchema.index({ campaign_code: 1 }, { unique: true });
+	return {
+		LicenseCampaignMeta: mongoose.model("LicenseCampaignMeta", LicenseCampaignMetaSchema),
+		LicenseCampaignRecord: mongoose.model("LicenseCampaignRecord", LicenseCampaignRecordSchema),
+		PublicAnnouncement: mongoose.model("PublicAnnouncement", PublicAnnouncementSchema),
+		PublicAnnouncementUserList: mongoose.model("PublicAnnouncementUserList", PublicAnnouncementUserListSchema),
+		PublicAnnouncementUserListLog: mongoose.model("PublicAnnouncementUserListLog", PublicAnnouncementUserListLog),
+		PublicAnnouncementFreeTrial: mongoose.model("PublicAnnouncementFreeTrial", PublicAnnouncementFreeTrialSchema),
+		IasBuyOption: mongoose.model("IasBuyOption", IasBuyOptionSchema),
+		IasStorePageMeta: mongoose.model("IasStorePageMeta", IasStorePageMetaSchema),
+		IasPromotion: mongoose.model("IasPromotion", IasPromotionSchema),
+		SpecialOffer: mongoose.model("SpecialOffer", SpecialOfferSchema),
+		Promotion: mongoose.model("Promotion", PromotionSchema),
+		CampaignUserInfo: mongoose.model("CampaignUserInfo", CampaignUserInfoSchema),
+		CouponPromotion: mongoose.model("CouponPromotion", CouponPromotionSchema),
+		TierSalesMeta: mongoose.model("TierSalesMeta", TierSalesMetaSchema),
+		TierSalesRules: mongoose.model("TierSalesRules", TierSalesRulesSchema),
+		GearTrialMeta: mongoose.model("GearTrialMeta", GearTrialMetaSchema),
+		GearTrialRecord: mongoose.model("GearTrialRecord", GearTrialRecordSchema),
+		YotpoLoyalty: mongoose.model("YotpoLoyalty", YotpoLoyaltySchema),
+		YotpoLoyaltyBackup: mongoose.model("YotpoLoyaltyBackup", YotpoLoyaltyBackupSchema),
+		FreeTrial: mongoose.model("FreeTrial", FreeTrialSchema)
+	};
+}
+//#endregion
+//#region src/models/redeem.ts
+function buildRedeem(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const RedeemCodeSchema = new Schema({
+		code: {
+			type: String,
+			required: true
+		},
+		product_id: {
+			type: ObjectId,
+			ref: "Product",
+			default: null
+		},
+		bundle_id: {
+			type: ObjectId,
+			ref: "Bundle",
+			default: null
+		},
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			default: null
+		},
+		status: {
+			type: Number,
+			default: 1,
+			required: true
+		},
+		expire_on: {
+			type: Date,
+			default: null
+		},
+		trial_due_date: {
+			type: Date,
+			default: null
+		},
+		tracker: {
+			type: String,
+			required: true
+		},
+		metadata: { type: Schema.Types.Mixed },
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_redeem_code" });
+	RedeemCodeSchema.index({
+		code: 1,
+		status: 1
+	}, { unique: true });
+	RedeemCodeSchema.index({
+		code: 1,
+		product_id: 1,
+		status: 1
+	});
+	RedeemCodeSchema.index({
+		code: 1,
+		bundle_id: 1,
+		status: 1
+	});
+	RedeemCodeSchema.index({ tracker: 1 });
+	return mongoose.model("RedeemCode", RedeemCodeSchema);
+}
+//#endregion
+//#region src/models/toneTheme.ts
+function buildToneTheme(mongoose) {
+	const { Schema } = mongoose;
+	const ToneThemeSchema = new Schema({
+		title: {
+			type: String,
+			required: true,
+			trim: true
+		},
+		description: {
+			type: String,
+			trim: true,
+			default: null
+		},
+		cover_image_url: {
+			type: String,
+			default: null
+		},
+		thumb_url: {
+			type: String,
+			default: null
+		},
+		order: {
+			type: Number,
+			default: 0
+		},
+		is_shown: {
+			type: Boolean,
+			default: false
+		},
+		list_for: {
+			type: String,
+			required: true
+		},
+		category: {
+			type: String,
+			default: null
+		},
+		tags: [{ type: String }],
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "tone_theme",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	ToneThemeSchema.index({
+		list_for: 1,
+		is_shown: 1,
+		order: 1,
+		created_on: -1
+	});
+	ToneThemeSchema.index({ category: 1 });
+	ToneThemeSchema.index({ tags: 1 });
+	ToneThemeSchema.plugin(mongooseLeanVirtuals);
+	ToneThemeSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	return mongoose.model("ToneTheme", ToneThemeSchema);
+}
+//#endregion
+//#region src/models/toneThemeFeaturedList.ts
+function buildToneThemeFeaturedList(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const ToneThemeFeaturedListSchema = new Schema({
+		tone_theme_id: {
+			type: ObjectId,
+			ref: "ToneTheme",
+			required: true
+		},
+		featured_list_id: {
+			type: ObjectId,
+			ref: "FeaturedList",
+			required: true
+		},
+		order: {
+			type: Number,
+			default: 0
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "tone_theme_featured_list" });
+	ToneThemeFeaturedListSchema.index({
+		tone_theme_id: 1,
+		order: 1
+	});
+	ToneThemeFeaturedListSchema.index({ featured_list_id: 1 });
+	ToneThemeFeaturedListSchema.index({
+		tone_theme_id: 1,
+		featured_list_id: 1
+	}, { unique: true });
+	return mongoose.model("ToneThemeFeaturedList", ToneThemeFeaturedListSchema);
+}
+//#endregion
+//#region src/models/user.ts
+const log$2 = debug("model:user");
+function encryptPassword(pwd) {
+	if (!pwd) return "";
+	const encryptType = "sha1";
+	const salt = randomString({
+		length: 5,
+		numeric: true,
+		letters: true
+	}).toLowerCase();
+	return `${encryptType}$${salt}$${crypto.createHash(encryptType).update(String(salt) + String(pwd)).digest("hex")}`;
+}
+function verifyPassword(pwd, pwdArr) {
+	if (!pwd) return false;
+	return crypto.createHash(pwdArr[0]).update(String(pwdArr[1]) + String(pwd)).digest("hex") === pwdArr[2];
+}
+const FLAG_EMAIL_EVENTS = [
+	"bounce",
+	"complaint",
+	"reject"
+];
+const jamupLitePattern = /JamUp.+Lite\/([0-9.]+)/;
+const biasAmpPattern = /Bias\/([0-9.]+)/;
+const biasAmpiPhonePattern = /Bias.+iPhone\/([0-9.]+)/;
+const biasFxPattern = /BIAS.+FX\/([0-9.]+).+iPad/;
+const biasPedalPattern = /BIAS.+Pedal\/([0-9.]+).+iPad/;
+function buildUser(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const UserEmailStatusSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		email_status: {
+			type: String,
+			enum: FLAG_EMAIL_EVENTS,
+			required: true
+		},
+		creted_on: {
+			type: Date,
+			default: Date.now,
+			required: true
+		}
+	}, { collection: "user_email_status" });
+	const UserProfileSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		full_name: {
+			type: String,
+			default: null
+		},
+		first_name: {
+			type: String,
+			default: null
+		},
+		last_name: {
+			type: String,
+			default: null
+		},
+		title: {
+			type: String,
+			default: null
+		},
+		gender: {
+			type: String,
+			default: null
+		},
+		country: {
+			type: String,
+			default: null
+		},
+		postal: {
+			type: String,
+			default: null
+		},
+		city: {
+			type: String,
+			default: null
+		},
+		state: {
+			type: String,
+			default: null
+		},
+		address: {
+			type: String,
+			default: null
+		},
+		phone: {
+			type: String,
+			default: null
+		},
+		description: { type: String },
+		bc_token: {
+			type: String,
+			default: null
+		},
+		facebook_access_token: {
+			type: String,
+			default: null
+		},
+		reset_password_token: {
+			type: String,
+			default: null
+		},
+		profile_image_url: {
+			type: String,
+			default: null
+		},
+		profile_thumb_url: {
+			type: String,
+			default: null
+		},
+		facebook_image_url: {
+			type: String,
+			default: null
+		},
+		facebook_thumb_url: {
+			type: String,
+			default: null
+		},
+		reset_password_expire: {
+			type: Date,
+			default: null
+		},
+		is_email_verified: {
+			type: Boolean,
+			default: false
+		},
+		is_registered: {
+			type: Boolean,
+			default: true
+		},
+		stripe_customer_id: {
+			type: String,
+			default: null
+		},
+		selected_country: {
+			type: String,
+			default: null
+		},
+		date_joined: {
+			type: Date,
+			default: Date.now
+		},
+		search_mark: {
+			type: Number,
+			default: 0
+		}
+	}, {
+		collection: "jamup_userprofile",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	UserProfileSchema.index({ user_id: 1 }, { unique: true });
+	UserProfileSchema.index({ reset_password_token: 1 });
+	UserProfileSchema.index({
+		full_name: "text",
+		first_name: "text",
+		last_name: "text"
+	});
+	const UserSchema = new Schema({
+		username: {
+			type: String,
+			trim: true,
+			required: true
+		},
+		email: {
+			type: String,
+			trim: true,
+			match: [/^\S+@\S+\.\S+$/, "Invalid Email Address"],
+			required: true
+		},
+		password: {
+			type: String,
+			default: null,
+			set: encryptPassword,
+			required: true
+		},
+		user_status: {
+			type: Number,
+			default: 1
+		},
+		user_role: {
+			type: Number,
+			default: 1
+		},
+		is_active: {
+			type: Boolean,
+			default: false
+		},
+		activate_token: {
+			type: String,
+			default: null
+		},
+		activate_expire: {
+			type: Date,
+			default: null
+		},
+		fb_access_token: {
+			type: String,
+			default: null
+		},
+		facebook_id: {
+			type: String,
+			default: null
+		},
+		shopify_id: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		bk_username: [{ type: String }],
+		auth: {
+			firebase_id: { type: String },
+			google_id: { type: String },
+			apple_id: { type: String },
+			wechat_id: { type: String }
+		},
+		metadata: {
+			gdpr: {
+				type: Boolean,
+				default: false
+			},
+			country: {
+				type: String,
+				default: null
+			}
+		},
+		date_joined: {
+			type: Date,
+			default: Date.now
+		},
+		last_login: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "auth_user",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	UserSchema.index({ shopify_id: 1 });
+	UserSchema.index({ username: 1 });
+	UserSchema.index({ email: 1 }, { unique: true });
+	UserSchema.index({ "auth.firebase_id": 1 });
+	UserSchema.index({ "auth.apple_id": 1 });
+	UserSchema.index({ "auth.facebook_id": 1 });
+	const UserProductSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		product: {
+			type: String,
+			required: true
+		},
+		platform: {
+			type: String,
+			required: true
+		},
+		metadata: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		last_login: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "user_product_meta" });
+	const UserProductTrackerSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		product: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Number,
+			default: 1
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "user_product_tracker" });
+	UserProductTrackerSchema.index({
+		user_id: 1,
+		product: 1
+	}, { unique: true });
+	const ApikeySchema = new Schema({
+		apikey: {
+			type: String,
+			required: true,
+			unique: true
+		},
+		permission: {
+			type: [String],
+			required: true
+		},
+		description: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: Boolean,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		call_number: { type: Number },
+		partner_name: { type: String },
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "auth_apikey" });
+	const UserReferralSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		referred_user_email: { type: String },
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		updated_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "user_referral" });
+	const UserTokenSchema = new Schema({
+		tid: {
+			type: String,
+			trim: true,
+			required: true
+		},
+		expired_at: {
+			type: Date,
+			required: true
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		collection: "auth_token",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	UserTokenSchema.index({ tid: 1 }, { unique: true });
+	UserTokenSchema.index({ expired_at: 1 }, { expireAfterSeconds: 0 });
+	const UserFollowSchema = new Schema({
+		user_id: {
+			type: Schema.Types.ObjectId,
+			ref: "User",
+			required: true,
+			index: true
+		},
+		follow_user_id: {
+			type: Schema.Types.ObjectId,
+			ref: "User",
+			required: true,
+			index: true
+		},
+		follow_platform: { type: String }
+	}, {
+		timestamps: {
+			createdAt: true,
+			updatedAt: false
+		},
+		versionKey: false,
+		collection: "jamup_userFollow",
+		toJSON: { virtuals: true },
+		toObject: { virtuals: true }
+	});
+	UserFollowSchema.index({
+		user_id: 1,
+		follow_platform: 1,
+		follow_user_id: 1
+	}, { unique: true });
+	UserSchema.method({
+		authenticate(plainText) {
+			const passwordArr = this.password.split("$");
+			if (passwordArr.length !== 3) return false;
+			return verifyPassword(plainText, passwordArr);
+		},
+		makeSalt() {
+			return `${Math.round((/* @__PURE__ */ new Date()).valueOf() * Math.random())}`;
+		}
+	});
+	UserTokenSchema.static({
+		async createTokenMeta() {
+			try {
+				const tid = crypto.randomUUID();
+				const nowDate = /* @__PURE__ */ new Date();
+				const expiredAt = new Date((/* @__PURE__ */ new Date()).setDate(nowDate.getDate() + 14));
+				return await this.create({
+					tid,
+					expired_at: expiredAt,
+					created_on: nowDate
+				});
+			} catch (err) {
+				log$2("ERR:createTokenMeta:%j", err);
+				throw err;
+			}
+		},
+		async isValid(tid) {
+			const userTokenMeta = await this.findOne({ tid }).exec();
+			return Boolean(userTokenMeta);
+		},
+		async revokeToken(tid) {
+			return this.findOneAndDelete({ tid }).exec();
+		}
+	});
+	UserSchema.static({
+		async _async_auth(username, password) {
+			const normalized = String(username).toLowerCase().replace("@", "_");
+			let user;
+			try {
+				user = await this.findOne({ username: normalized }).exec();
+			} catch (err) {
+				throw new ApiErrorCode("internal_sysmtem_error", err.message);
+			}
+			if (!user) {
+				let bgUser;
+				try {
+					bgUser = await this.findOne({ bk_username: { $in: [normalized] } }).exec();
+				} catch (err) {
+					throw new ApiErrorCode("INTERNAL_SYSMTEM_ERROR", err.message);
+				}
+				if (!bgUser) throw new ApiErrorCode("USER_NOT_EXIST", `Cannot find user ${normalized}`);
+				else if (!bgUser.authenticate(password)) throw new ApiErrorCode("USER_UNAUTHORIZED", "unauthorized");
+				return bgUser;
+			}
+			if (user.user_status === 2) throw new ApiErrorCode("ACCOUNT_WERE_DELETED", `Account ${user.email} already deleted`);
+			if (!user.authenticate(password)) {
+				if (user.facebook_id !== null) throw new ApiErrorCode("USER_OAUTH_LOGIN", "Please use FB to login your account");
+				throw new ApiErrorCode("USER_UNAUTHORIZED", "unauthorized");
+			}
+			return user;
+		},
+		auth(uname, password, cb) {
+			if (!cb) return this._async_auth(uname, password);
+			this._async_auth(uname, password).then((user) => cb(null, user), (err) => cb(err));
+		},
+		login(query, cb) {
+			if (!_.isObject(query)) return cb(/* @__PURE__ */ new Error("Invalid login parameter"));
+			this.findOne(query).then((u) => cb(null, u), (err) => cb(err));
+		},
+		loginForPassport(query, cb) {
+			if (!_.isObject(query)) return cb(/* @__PURE__ */ new Error("Invalid login parameter"));
+			const q = query;
+			if (_.has(q, "username")) q.username = String(_.trim(q.username)).toLowerCase();
+			if (_.has(q, "email")) q.email = String(_.trim(q.email)).toLowerCase();
+			this.findOne(q).then((user) => {
+				if (!user) return cb({
+					status: 404,
+					errorMessage: "Cannot found target user"
+				});
+				if (user.user_status === 2) return cb({
+					status: 410,
+					errorMessage: "This account already deleted"
+				});
+				return cb(null, user);
+			}, (err) => cb({
+				status: 500,
+				errorMessage: err
+			}));
+		},
+		list(options, cb) {
+			const criteria = options.criteria ?? {};
+			const sort = options.sort ?? { createdAt: -1 };
+			const limit = options.limit === 0 ? 0 : options.limit ?? 10;
+			const page = options.page ?? 0;
+			this.find(criteria).select("name username email").sort(sort).skip(limit * page).limit(limit).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		getUser(username, cb) {
+			this.findOne({ username: String(username).toLowerCase() }).sort({ date_joined: -1 }).select("email user_role user_status auth").then((u) => cb(null, u), (err) => cb(err));
+		},
+		async getUserPromise(username) {
+			return await this.findOne({ username: String(username).toLowerCase() }).select("email user_role user_status auth").exec();
+		},
+		getUserById(id, cb) {
+			this.findById(id).then((u) => cb(null, u), (err) => cb(err));
+		},
+		async getUserFullData(username) {
+			const cursor = this.aggregate([
+				{ $match: {
+					username: String(username).toLowerCase(),
+					user_status: 1
+				} },
+				{ $lookup: {
+					from: "jamup_userprofile",
+					localField: "_id",
+					foreignField: "user_id",
+					as: "userprofile"
+				} },
+				{ $unwind: "$userprofile" }
+			]).cursor({ batchSize: 100 });
+			const results = [];
+			for await (const doc of cursor) results.push(doc);
+			return results;
+		},
+		async getUserDetail(query, projectFields = {}) {
+			try {
+				if (!_.isObject(query)) throw new Error("Query need to be object!");
+				const queryCondition = _.assign({}, { user_status: 1 }, query);
+				const defaultProjectFields = _.assign({}, {
+					_id: 1,
+					email: 1,
+					username: 1,
+					date_joined: 1,
+					last_login: 1,
+					"userprofile.first_name": 1,
+					"userprofile.last_name": 1,
+					"userprofile.full_name": 1
+				}, projectFields);
+				return await this.aggregate([
+					{ $match: queryCondition },
+					{ $lookup: {
+						from: "jamup_userprofile",
+						localField: "_id",
+						foreignField: "user_id",
+						as: "userprofile"
+					} },
+					{ $unwind: "$userprofile" },
+					{ $project: defaultProjectFields }
+				]).exec();
+			} catch (err) {
+				log$2("ERR:getUserDetail %o", err);
+				throw err;
+			}
+		},
+		async getDealerDetail(query) {
+			try {
+				if (!_.isObject(query)) throw new Error("Query need to be object!");
+				const queryCondition = _.assign({}, { user_status: 1 }, query);
+				return await this.aggregate([
+					{ $match: queryCondition },
+					{ $lookup: {
+						from: "jamup_userprofile",
+						localField: "_id",
+						foreignField: "user_id",
+						as: "userprofile"
+					} },
+					{ $unwind: "$userprofile" },
+					{ $lookup: {
+						from: "b2b_dealer_profile",
+						localField: "_id",
+						foreignField: "dealer_id",
+						as: "dealer"
+					} },
+					{ $unwind: "$dealer" }
+				]).exec();
+			} catch (err) {
+				log$2("ERR:getDealerDetail %o", err);
+				throw err;
+			}
+		},
+		createUser(userObj, cb) {
+			this.create(userObj).then((u) => cb(null, u), (err) => cb(err));
+		},
+		deleteUser(userId, cb) {
+			this.deleteOne({ _id: userId }).then((r) => cb(null, r), (err) => cb(err));
+		},
+		findUserByEmail(email, cb) {
+			this.find({ email: String(email).toLowerCase() }).then((docs) => cb(null, docs), (err) => cb(err));
+		},
+		async findByEmail(email) {
+			try {
+				if (!isEmail(email)) throw new Error(`Invalid email format: ${email}`);
+				return await this.findOne({
+					email: String(email).toLowerCase(),
+					user_status: 1
+				}).exec();
+			} catch (err) {
+				log$2("ERR:findByEmail:%o", email);
+				throw err;
+			}
+		}
+	});
+	UserProfileSchema.static({
+		createProfile(profileObj, cb) {
+			if (!profileObj.user_id) return cb(/* @__PURE__ */ new Error("Missing User Id"));
+			if (!mongoose.Types.ObjectId.isValid(profileObj.user_id)) return cb(/* @__PURE__ */ new Error("Invalid User Id"));
+			this.create(profileObj).then((doc) => cb(null, doc), (err) => cb(err));
+		},
+		updateProfileByUserId(userId, updateData, cb) {
+			this.findOneAndUpdate({ user_id: userId }, { $set: updateData }, { new: true }).then((doc) => cb(null, doc), (err) => cb(err));
+		},
+		async updateProfile(userId, updateProfileData) {
+			try {
+				return await this.findOneAndUpdate({ user_id: new mongoose.Types.ObjectId(userId) }, { $set: updateProfileData }, { new: true }).exec();
+			} catch (err) {
+				log$2("ERR:updateProfile:%o", err);
+				throw err;
+			}
+		},
+		getUserProfile(userId, cb) {
+			this.getUserProfilePromise(userId).then((data) => cb(null, data), (err) => cb(err));
+		},
+		async getUserProfilePromise(userId) {
+			const selectField = [
+				"full_name",
+				"profile_image_url",
+				"profile_thumb_url",
+				"first_name",
+				"last_name",
+				"title",
+				"gender",
+				"date_joined"
+			].join(" ");
+			return await this.findOne({ user_id: userId }).select(selectField).exec();
+		},
+		getUserProfileDetail(userId, cb) {
+			if (!cb) return this.findOne({ user_id: userId }).exec();
+			this.findOne({ user_id: userId }).then((d) => cb(null, d), (err) => cb(err));
+		},
+		getUserProfileByCondition(condition, cb) {
+			this.findOne(condition).then((d) => cb(null, d), (err) => cb(err));
+		}
+	});
+	UserProductSchema.static({ detectUserProduct(userAgent) {
+		const preUserAgent = String(userAgent);
+		if (jamupLitePattern.test(preUserAgent)) return {
+			product: "jamup-lite",
+			platform: "iOS"
+		};
+		if (biasAmpPattern.test(preUserAgent)) return {
+			product: "biasamp",
+			platform: "iOS"
+		};
+		if (biasAmpiPhonePattern.test(preUserAgent)) return {
+			product: "biasamp",
+			platform: "iOS"
+		};
+		if (biasFxPattern.test(preUserAgent)) return {
+			product: "biasfx",
+			platform: "iOS"
+		};
+		if (biasPedalPattern.test(preUserAgent)) return {
+			product: "pedal",
+			platform: "iOS"
+		};
+		return false;
+	} });
+	UserSchema.virtual("id").get(function() {
+		return this._id.toHexString();
+	});
+	return {
+		User: mongoose.model("User", UserSchema),
+		UserProfile: mongoose.model("UserProfile", UserProfileSchema),
+		ApiKey: mongoose.model("ApiKey", ApikeySchema),
+		UserProduct: mongoose.model("UserProduct", UserProductSchema),
+		UserProductTracker: mongoose.model("UserProductTracker", UserProductTrackerSchema),
+		UserReferral: mongoose.model("UserReferral", UserReferralSchema),
+		UserEmailStatus: mongoose.model("UserEmailStatus", UserEmailStatusSchema),
+		UserToken: mongoose.model("UserToken", UserTokenSchema),
+		UserFollow: mongoose.model("UserFollow", UserFollowSchema)
+	};
+}
+//#endregion
+//#region src/models/userTrack.ts
+const log$1 = debug("model:usertrack");
+const LICENSE_ADDITION = {
+	PRO: 0,
+	DEMO: 1,
+	STD: 2,
+	LITE: 3,
+	ELITE: 4
+};
+const PRODUCTS = [
+	"fx2",
+	"amp2",
+	"fx1",
+	"amp1"
+];
+function buildUserTrack(mongoose) {
+	const { Schema } = mongoose;
+	const ObjectId = Schema.Types.ObjectId;
+	const GenericDataSchema = new Schema({
+		data_type: {
+			type: String,
+			required: true
+		},
+		data_key: {
+			type: String,
+			required: true
+		},
+		data_value: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		data_meta: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "pg_generic_data" });
+	const IapEventSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		app_name: {
+			type: String,
+			required: true
+		},
+		onesignal_id: {
+			type: String,
+			default: null
+		},
+		redeem_code: {
+			type: ObjectId,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		},
+		region: {
+			type: String,
+			required: false
+		}
+	}, { collection: "pg_iap_event" });
+	const DemoUserTrackerSchema = new Schema({
+		user_id: {
+			type: ObjectId,
+			ref: "User",
+			required: true
+		},
+		product: {
+			type: String,
+			required: true
+		},
+		addition: {
+			type: Number,
+			required: true
+		},
+		started_at: {
+			type: Date,
+			required: true
+		},
+		updated_at: {
+			type: Date,
+			default: null
+		},
+		created_on: {
+			type: Date,
+			default: Date.now
+		}
+	}, { collection: "demo_user_tracker" });
+	DemoUserTrackerSchema.index({
+		user_id: 1,
+		product: 1,
+		addition: 1,
+		started_at: 1,
+		updated_at: 1
+	}, { unique: true });
+	DemoUserTrackerSchema.static({ async saveTrackData(data) {
+		try {
+			const { product, addition } = data;
+			const userID = new mongoose.Types.ObjectId(data.userID);
+			const startedAt = parseInt(String(data.startedAt), 10);
+			if (!mongoose.Types.ObjectId.isValid(userID) || PRODUCTS.indexOf(product) === -1 || Object.keys(LICENSE_ADDITION).indexOf(addition) === -1) throw new Error(`Invalid parameter: ${String(userID)}/${product}/${addition}`);
+			else if (!startedAt || !moment(startedAt).isValid()) throw new Error(`Invalid timestamp format: ${startedAt}/${data.updatedAt}`);
+			const trackData = {
+				user_id: userID,
+				product,
+				addition: LICENSE_ADDITION[addition],
+				started_at: moment(startedAt).toDate()
+			};
+			if (_.has(data, "updatedAt")) {
+				const updatedAt = parseInt(String(data.updatedAt), 10);
+				if (updatedAt && moment(updatedAt).isValid()) trackData.updated_at = moment(updatedAt).toDate();
+			}
+			if (!await this.findOne(trackData).exec()) await this.create(trackData);
+			return true;
+		} catch (err) {
+			log$1("ERR:handleLicensePurchaseData:%j", err);
+			throw err;
+		}
+	} });
+	return {
+		GenericData: mongoose.model("GenericData", GenericDataSchema),
+		IapEvent: mongoose.model("IapEvent", IapEventSchema),
+		DemoUserTracker: mongoose.model("DemoUserTracker", DemoUserTrackerSchema)
+	};
+}
+//#endregion
+//#region src/index.ts
+const log = debug("model:init");
+const ALL_BUILDERS = [
+	buildBanks,
+	buildDevice,
+	buildFeaturedList,
+	buildHardware,
+	buildHomeConfig,
+	buildOauth,
+	buildPartner,
+	buildPayment,
+	buildPgConfig,
+	buildPreset,
+	buildPromotion,
+	buildRedeem,
+	buildToneTheme,
+	buildToneThemeFeaturedList,
+	buildUser,
+	buildUserTrack
+];
+function register(mongoose, type) {
+	log("Loading type: %s", type);
+	if (type === "account") {
+		buildUser(mongoose);
+		buildOauth(mongoose);
+		buildPartner(mongoose);
+		buildPayment(mongoose);
+		buildHardware(mongoose);
+		return;
+	}
+	if (type === "hardware") {
+		buildHardware(mongoose);
+		return;
+	}
+	for (const build of ALL_BUILDERS) build(mongoose);
+}
+//#endregion
+export { register as default, register };