monorepo packages (#344)

projects/app/src/service/models/app.ts

@@ -0,0 +1,70 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { AppSchema as AppType } from '@/types/mongoSchema';
+
+const AppSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  name: {
+    type: String,
+    required: true
+  },
+  type: {
+    type: String,
+    default: 'advanced',
+    enum: ['basic', 'advanced']
+  },
+  avatar: {
+    type: String,
+    default: '/icon/logo.svg'
+  },
+  intro: {
+    type: String,
+    default: ''
+  },
+  updateTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  share: {
+    topNum: {
+      type: Number,
+      default: 0
+    },
+    isShare: {
+      type: Boolean,
+      default: false
+    },
+    isShareDetail: {
+      // share model detail info. false: just show name and intro
+      type: Boolean,
+      default: false
+    },
+    intro: {
+      type: String,
+      default: '',
+      maxlength: 150
+    },
+    collection: {
+      type: Number,
+      default: 0
+    }
+  },
+  modules: {
+    type: Array,
+    default: []
+  },
+  // 弃
+  chat: Object
+});
+
+try {
+  AppSchema.index({ updateTime: -1 });
+  AppSchema.index({ 'share.collection': -1 });
+} catch (error) {
+  console.log(error);
+}
+
+export const App: Model<AppType> = models['app'] || model('app', AppSchema);

projects/app/src/service/models/chat.ts

@@ -0,0 +1,82 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { ChatSchema as ChatType } from '@/types/mongoSchema';
+import { ChatRoleMap, TaskResponseKeyEnum } from '@/constants/chat';
+import { ChatSourceMap } from '@/constants/chat';
+
+const ChatSchema = new Schema({
+  chatId: {
+    type: String,
+    require: true
+  },
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  appId: {
+    type: Schema.Types.ObjectId,
+    ref: 'model',
+    required: true
+  },
+  updateTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  title: {
+    type: String,
+    default: '历史记录'
+  },
+  customTitle: {
+    type: String,
+    default: ''
+  },
+  top: {
+    type: Boolean
+  },
+  variables: {
+    type: Object,
+    default: {}
+  },
+  source: {
+    type: String,
+    enum: Object.keys(ChatSourceMap),
+    required: true
+  },
+  shareId: {
+    type: String
+  },
+  isInit: {
+    type: Boolean,
+    default: false
+  },
+  content: {
+    type: [
+      {
+        obj: {
+          type: String,
+          required: true,
+          enum: Object.keys(ChatRoleMap)
+        },
+        value: {
+          type: String,
+          default: ''
+        },
+        [TaskResponseKeyEnum.responseData]: {
+          type: Array,
+          default: []
+        }
+      }
+    ],
+    default: []
+  }
+});
+
+try {
+  ChatSchema.index({ userId: 1 });
+  ChatSchema.index({ updateTime: -1 });
+  ChatSchema.index({ appId: 1 });
+} catch (error) {
+  console.log(error);
+}
+
+export const Chat: Model<ChatType> = models['chat'] || model('chat', ChatSchema);

projects/app/src/service/models/chatItem.ts

@@ -0,0 +1,67 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { ChatItemSchema as ChatItemType } from '@/types/mongoSchema';
+import { ChatRoleMap, TaskResponseKeyEnum } from '@/constants/chat';
+import { customAlphabet } from 'nanoid';
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyz1234567890', 24);
+
+const ChatItemSchema = new Schema({
+  dataId: {
+    type: String,
+    require: true,
+    default: () => nanoid()
+  },
+  chatId: {
+    type: String,
+    require: true
+  },
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  appId: {
+    type: Schema.Types.ObjectId,
+    ref: 'model',
+    required: true
+  },
+  time: {
+    type: Date,
+    default: () => new Date()
+  },
+  obj: {
+    type: String,
+    required: true,
+    enum: Object.keys(ChatRoleMap)
+  },
+  value: {
+    type: String,
+    default: ''
+  },
+  userFeedback: {
+    type: String
+  },
+  adminFeedback: {
+    type: {
+      kbId: String,
+      dataId: String,
+      content: String
+    }
+  },
+  [TaskResponseKeyEnum.responseData]: {
+    type: Array,
+    default: []
+  }
+});
+
+try {
+  ChatItemSchema.index({ time: -1 });
+  ChatItemSchema.index({ userId: 1 });
+  ChatItemSchema.index({ appId: 1 });
+  ChatItemSchema.index({ chatId: 1 });
+  ChatItemSchema.index({ userFeedback: 1 });
+} catch (error) {
+  console.log(error);
+}
+
+export const ChatItem: Model<ChatItemType> =
+  models['chatItem'] || model('chatItem', ChatItemSchema);

projects/app/src/service/models/collection.ts

@@ -0,0 +1,18 @@
+import { Schema, model, models, Model as MongoModel } from 'mongoose';
+import { CollectionSchema as CollectionType } from '@/types/mongoSchema';
+
+const CollectionSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  appId: {
+    type: Schema.Types.ObjectId,
+    ref: 'model',
+    required: true
+  }
+});
+
+export const Collection: MongoModel<CollectionType> =
+  models['collection'] || model('collection', CollectionSchema);

projects/app/src/service/models/image.ts

@@ -0,0 +1,15 @@
+import { Schema, model, models, Model } from 'mongoose';
+
+const ImageSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  binary: {
+    type: Buffer
+  }
+});
+
+export const Image: Model<{ userId: string; binary: Buffer }> =
+  models['image'] || model('image', ImageSchema);

projects/app/src/service/models/inform.ts

@@ -0,0 +1,40 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { informSchema } from '@/types/mongoSchema';
+import { InformTypeMap } from '@/constants/user';
+
+const InformSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  time: {
+    type: Date,
+    default: () => new Date()
+  },
+  type: {
+    type: String,
+    enum: Object.keys(InformTypeMap)
+  },
+  title: {
+    type: String,
+    required: true
+  },
+  content: {
+    type: String,
+    required: true
+  },
+  read: {
+    type: Boolean,
+    default: false
+  }
+});
+
+try {
+  InformSchema.index({ time: -1 });
+  InformSchema.index({ userId: 1 });
+} catch (error) {
+  console.log(error);
+}
+
+export const Inform: Model<informSchema> = models['inform'] || model('inform', InformSchema);

projects/app/src/service/models/kb.ts

@@ -0,0 +1,45 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { kbSchema as SchemaType } from '@/types/mongoSchema';
+import { KbTypeMap } from '@/constants/dataset';
+
+const kbSchema = new Schema({
+  parentId: {
+    type: Schema.Types.ObjectId,
+    ref: 'kb',
+    default: null
+  },
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  updateTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  avatar: {
+    type: String,
+    default: '/icon/logo.svg'
+  },
+  name: {
+    type: String,
+    required: true
+  },
+  vectorModel: {
+    type: String,
+    required: true,
+    default: 'text-embedding-ada-002'
+  },
+  type: {
+    type: String,
+    enum: Object.keys(KbTypeMap),
+    required: true,
+    default: 'dataset'
+  },
+  tags: {
+    type: [String],
+    default: []
+  }
+});
+
+export const KB: Model<SchemaType> = models['kb'] || model('kb', kbSchema);

projects/app/src/service/models/pay.ts

@@ -0,0 +1,29 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { PaySchema as PayType } from '@/types/mongoSchema';
+const PaySchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  createTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  price: {
+    type: Number,
+    required: true
+  },
+  orderId: {
+    type: String,
+    required: true
+  },
+  status: {
+    // 支付的状态
+    type: String,
+    default: 'NOTPAY',
+    enum: ['SUCCESS', 'REFUND', 'NOTPAY', 'CLOSED']
+  }
+});
+
+export const Pay: Model<PayType> = models['pay'] || model('pay', PaySchema);

projects/app/src/service/models/promotionRecord.ts

@@ -0,0 +1,31 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { PromotionRecordSchema as PromotionRecordType } from '@/types/mongoSchema';
+
+const PromotionRecordSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  objUId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: false
+  },
+  createTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ['pay', 'register']
+  },
+  amount: {
+    type: Number,
+    required: true
+  }
+});
+
+export const promotionRecord: Model<PromotionRecordType> =
+  models['promotionRecord'] || model('promotionRecord', PromotionRecordSchema);

projects/app/src/service/models/trainingData.ts

@@ -0,0 +1,72 @@
+/* 模型的知识库 */
+import { Schema, model, models, Model as MongoModel } from 'mongoose';
+import { TrainingDataSchema as TrainingDateType } from '@/types/mongoSchema';
+import { TrainingTypeMap } from '@/constants/plugin';
+
+// pgList and vectorList, Only one of them will work
+const TrainingDataSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'user',
+    required: true
+  },
+  kbId: {
+    type: Schema.Types.ObjectId,
+    ref: 'kb',
+    required: true
+  },
+  expireAt: {
+    type: Date,
+    default: () => new Date()
+  },
+  lockTime: {
+    type: Date,
+    default: () => new Date('2000/1/1')
+  },
+  mode: {
+    type: String,
+    enum: Object.keys(TrainingTypeMap),
+    required: true
+  },
+  vectorModel: {
+    type: String,
+    required: true,
+    default: 'text-embedding-ada-002'
+  },
+  prompt: {
+    // qa split prompt
+    type: String,
+    default: ''
+  },
+  q: {
+    type: String,
+    default: ''
+  },
+  a: {
+    type: String,
+    default: ''
+  },
+  source: {
+    type: String,
+    default: ''
+  },
+  file_id: {
+    type: String,
+    default: ''
+  },
+  billId: {
+    type: String,
+    default: ''
+  }
+});
+
+try {
+  TrainingDataSchema.index({ lockTime: 1 });
+  TrainingDataSchema.index({ userId: 1 });
+  TrainingDataSchema.index({ expireAt: 1 }, { expireAfterSeconds: 7 * 24 * 60 });
+} catch (error) {
+  console.log(error);
+}
+
+export const TrainingData: MongoModel<TrainingDateType> =
+  models['trainingData'] || model('trainingData', TrainingDataSchema);

projects/app/src/service/models/user.ts

@@ -0,0 +1,59 @@
+import { Schema, model, models, Model } from 'mongoose';
+import { hashPassword } from '@/service/utils/tools';
+import { PRICE_SCALE } from '@fastgpt/common/bill/constants';
+import { UserModelSchema } from '@/types/mongoSchema';
+
+const UserSchema = new Schema({
+  username: {
+    // 可以是手机/邮箱，新的验证都只用手机
+    type: String,
+    required: true,
+    unique: true // 唯一
+  },
+  password: {
+    type: String,
+    required: true,
+    set: (val: string) => hashPassword(val),
+    get: (val: string) => hashPassword(val),
+    select: false
+  },
+  createTime: {
+    type: Date,
+    default: () => new Date()
+  },
+  avatar: {
+    type: String,
+    default: '/icon/human.png'
+  },
+  balance: {
+    type: Number,
+    default: 2 * PRICE_SCALE
+  },
+  inviterId: {
+    // 谁邀请注册的
+    type: Schema.Types.ObjectId,
+    ref: 'user'
+  },
+  promotionRate: {
+    type: Number,
+    default: 15
+  },
+  limit: {
+    exportKbTime: {
+      // Every half hour
+      type: Date
+    }
+  },
+  openaiAccount: {
+    type: {
+      key: String,
+      baseUrl: String
+    }
+  },
+  timezone: {
+    type: String,
+    default: 'Asia/Shanghai'
+  }
+});
+
+export const User: Model<UserModelSchema> = models['user'] || model('user', UserSchema);