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

package/index.js

@@ -1,28 +0,0 @@
-'use strict'
-
-const fs = require('fs')
-const path = require('path')
-const debug = require('debug')('model:init')
-
-/**
- * mongoose - mongoose instance
- * type - {account}
- */
-module.exports = function (mongoose, type) {
-  debug('Loading type: %s', type)
-  if (type === 'account') {
-    require(path.join(__dirname, '/models/user.js'))(mongoose)
-    require(path.join(__dirname, '/models/oauth.js'))(mongoose)
-    require(path.join(__dirname, '/models/partner.js'))(mongoose)
-    require(path.join(__dirname, '/models/payment.js'))(mongoose)
-    require(path.join(__dirname, '/models/hardware.js'))(mongoose)
-  } else if (type === 'hardware') {
-    require(path.join(__dirname, '/models/hardware.js'))(mongoose)
-  } else {
-    fs.readdirSync(path.join(__dirname, '/models')).forEach(file => {
-      if (file.match(/\.js/)) {
-        require(path.join(__dirname, '/models/', file))(mongoose)
-      }
-    })
-  }
-}

package/models/banks.js

@@ -1,42 +0,0 @@
-'use strict'
-
-const debug = require('debug')('model:banks')
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  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 }, // 1:active
-    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 })
-
-  mongoose.model('BankPresets', BankPresetsSchema)
-  mongoose.model('BankList', BankListSchema)
-}

package/models/device.js

@@ -1,51 +0,0 @@
-'use strict'
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  var 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' })
-
-  // main_product follow the iap defined in Product schema:
-  // extra_payment_fields.main_product
-  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 }, // 0:deactivate/1:activate
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'iap_activation' })
-
-  var 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 }, // 0: inactive 1:active
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_activationstatus' })
-
-  DeviceSchema.static({
-    getFeaturedPresetListByCondition: function (queryObj, cb) {
-      this.find(queryObj).select('-is_shown -order').exec(cb)
-    }
-  })
-
-  mongoose.model('Device', DeviceSchema)
-  mongoose.model('ActivationStatus', ActivationStatusSchema)
-  mongoose.model('IapActivation', IapActivationSchema)
-}

package/models/featuredList.js

@@ -1,91 +0,0 @@
-'use strict'
-
-const _ = require('lodash')
-const mongooseLeanVirtuals = require('mongoose-lean-virtuals');
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  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 }, // product_id/custom_metadata
-    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: function (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: function (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()
-    })
-
-  mongoose.model('FeaturedList', FeaturedListSchema)
-  mongoose.model('FeaturedPreset', FeaturedPresetSchema)
-}

package/models/hardware.js

@@ -1,256 +0,0 @@
-'use strict'
-
-const _ = require('lodash')
-const debug = require('debug')('model:promo')
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  const HardwareSeriesNumberSchema = new Schema({
-    hw_sn: { type: String, required: true },
-    channel: { type: String, default: null }, // Hardware sales channel: amazon
-    status: { type: 'Number', default: 1 }, //1:normal/2:deactived/3:blacklist
-    metadata: { type: Schema.Types.Mixed },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'hardware_seriesnumber' })
-
-  const HardwareActivationMetaSchema = new Schema({
-    pattern: { type: Array, required: true },
-    hw_sn_pattern: { type: Schema.Types.Mixed, required: true }, // pattern detail can jump to parseHardwareSeriesNumber
-    hw_activate_license: [{ type: ObjectId, ref: 'Product' }],
-    status: { type: Number, required: true, default: 1 }, // 1:enable 2:disable
-    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 }, // 1:activate 2:deactivate
-    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 }, //1:valid/2:preorder
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'country_hardaware_sku' })
-
-  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 Error(`Invalid hardware series number format: ${hwSn}`)
-    }
-
-    // Separate Spark with different Serial Number format
-    // old: https://docs.google.com/spreadsheets/d/1JGUigUU4UhY4ZWUDEhzQCDlKOd7Z5nHfHbFLw8riCsM/edit#gid=1816344881
-    // new: https://docs.google.com/spreadsheets/d/1AZhKe2_M6kJ3lGqEUEWCN24ziOnW5gmV-DrV_mV2GEY/edit#gid=432186548
-    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 Error(`Cannot identify hardware model: ${hwModel}`)
-      }
-
-      return {
-        hwName,
-        hwModel,
-        hwWattage,
-        hwProductType,
-        hwVersion,
-        hwYear,
-        hwMonth,
-        hwPattern
-      }
-    } else {
-      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 Error(`Cannot identify hardware model: ${hwModel}`)
-      }
-
-      return {
-        hwModel,
-        hwWattage,
-        hwVersion,
-        hwProductionPhase,
-        hwName,
-        hwPattern
-      }
-    }
-  }
-
-  HardwareSeriesNumberSchema.static({
-    // doc: https://docs.google.com/spreadsheets/d/1JGUigUU4UhY4ZWUDEhzQCDlKOd7Z5nHfHbFLw8riCsM/edit#gid=1816344881
-    parseHardwareSeriesNumber: function (hwSn) {
-      return new Promise((resolve, reject) => {
-        try {
-          const ret = _parseHardwareSerialNumber(hwSn)
-          return resolve(ret)
-        } catch (e) {
-          return reject(e)
-        }
-      })
-    },
-    parseHardwareSerialNumberNoPromise: function (hwSn) {
-      try {
-        return _parseHardwareSerialNumber(hwSn)
-      } catch (e) {
-        return e.message
-      }
-    }
-  })
-
-  HardwareActivationMetaSchema.static({
-    findMostMatchingMeta: async function (snPatternArr, opts = {}) {
-      try {
-        let allMatch = await this.find({ pattern: { '$in': snPatternArr } }).sort({ created_on: -1 }).lean().exec()
-
-        if (!allMatch || allMatch.length <= 0) {
-          if (opts.allowEmpty && opts.allowEmpty === true) {
-            return null
-          } else {
-            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) {
-            let 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 && opts.allowEmpty === true) {
-            return null
-          } else {
-            throw new Error('Cannot find any activation meta match the SN pattern')
-          }
-        } else {
-          return mostMatchingMeta
-        }
-      } catch (err) {
-        debug('ERROR:findMostMatchingMeta %o', err)
-        throw err
-      }
-    }
-  })
-
-  mongoose.model('HardwareActivationRecord', HardwareActivationRecordSchema)
-  mongoose.model('HardwareActivationMeta', HardwareActivationMetaSchema)
-  mongoose.model('HardwareSeriesNumber', HardwareSeriesNumberSchema)
-  mongoose.model('HardwareActivationConflict', HardwareActivationConflictSchema)
-  mongoose.model('PartnerCoupon', PartnerCouponSchema)
-  mongoose.model('WarehouseInventory', WarehouseInventorySchema)
-  mongoose.model('ItemInventoryHistory', ItemInventoryHistorySchema)
-  mongoose.model('CountryHardwareSku', CountryHardwareSkuSchema)
-}

package/models/homeConfig.js

@@ -1,97 +0,0 @@
-"use strict";
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema;
-
-  const DataSourceSchema = new Schema(
-    {
-      type: {
-        type: String,
-        enum: ["tone_theme_query", "tone_theme_ids", "tone_theme_id"],
-        required: true,
-      },
-      // 單一 theme ID（當 type = 'tone_theme_id'）
-      tone_theme_id: {
-        type: String,
-        default: null,
-      },
-      // 動態查詢（當 type = 'tone_theme_query'）
-      query: {
-        type: Schema.Types.Mixed,
-        default: null,
-      },
-      // 多個 theme IDs（當 type = 'tone_theme_ids'）
-      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,
-  });
-
-  mongoose.model("HomeConfig", HomeConfigSchema);
-};

package/models/oauth.js

@@ -1,52 +0,0 @@
-'use strict'
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-  const deepPopulate = require('mongoose-deep-populate')(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 } })
-
-  // auth_ authorizationCodes
-  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, {})
-
-  // auth_accessTokens
-  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 } })
-
-  // refreshTokens
-  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 } })
-
-  mongoose.model('OauthClient', clientSchema)
-  mongoose.model('RefreshTokens', RefreshTokenSchema)
-  mongoose.model('AccessToken', AccessTokenSchema)
-  mongoose.model('AuthorizationCode', AuthorizationCodeSchema)
-}