@brimble/models 3.8.77 → 3.8.79

package/env.ts

@@ -1,38 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ENVIRONMENT } from "./enum";
-import { IEnv } from "./types";
-
-const envSchema = new Schema(
-  {
-    project: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-    },
-    name: {
-      type: String,
-      required: true,
-    },
-    value: {
-      type: String,
-      required: false,
-    },
-    user: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    environment: {
-      type: String,
-      default: ENVIRONMENT.PRODUCTION,
-      required: true,
-    },
-    is_system: {
-      type: Boolean,
-      default: false,
-      required: false,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IEnv>("Env", envSchema);

package/environment-variable.ts

@@ -1,21 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IEnvironmentVariable } from "./types";
-
-const environmentVariableSchema = new Schema(
-  {
-    name: { type: String, required: true },
-    value: { type: String, required: true },
-    project_environment: {
-      ref: "ProjectEnvironment",
-      type: Schema.Types.ObjectId,
-      required: true,
-    },
-    user: { ref: "User", type: Schema.Types.ObjectId, required: true },
-    inheritable: { type: Boolean, default: true },
-  },
-  { timestamps: true },
-);
-
-environmentVariableSchema.index({ name: 1, project_environment: 1 }, { unique: true });
-
-export default model<IEnvironmentVariable>("EnvironmentVariable", environmentVariableSchema);

package/follower.ts

@@ -1,19 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IFollowing } from "./types";
-
-const followingSchema: Schema = new Schema(
-  {
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    followed_id: {
-      type: Schema.Types.ObjectId,
-      required: true,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IFollowing>("Following", followingSchema);

package/following.ts

@@ -1,19 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IFollowing } from "./types";
-
-const followingSchema: Schema = new Schema(
-  {
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    followed_id: {
-      type: Schema.Types.ObjectId,
-      required: true,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IFollowing>("Following", followingSchema);

package/framework.ts

@@ -1,88 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IFramework } from "./types";
-import { FrameworkApplicationType } from "./enum";
-
-const frameworkSchema: Schema = new Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-    },
-    slug: {
-      type: String,
-      required: true,
-    },
-    demo: {
-      type: String,
-      required: false,
-    },
-    logo: {
-      type: String,
-      required: true,
-    },
-    supported: {
-      type: Boolean,
-      required: false,
-      default: true
-    },
-    port: {
-      type: Number,
-      required: false,
-      default: 8000
-    },
-    tagline: {
-      type: String,
-      required: false,
-    },
-    description: {
-      type: String,
-      required: false,
-    },
-    website: {
-      type: String,
-      required: true,
-    },
-    envPrefix: {
-      type: String,
-      required: false,
-    },
-    detector: {
-      type: String,
-      required: true,
-    },
-    file_detectors: {
-      type: Array,
-      required: false
-    },
-    type: {
-      type: String,
-      enum: Object.values(FrameworkApplicationType),
-      required: true,
-    },
-    settings: {
-      installCommand: {
-        type: String,
-        required: false,
-      },
-      buildCommand: {
-        type: String,
-        required: true,
-      },
-      outputDirectory: {
-        type: String,
-        required: true,
-      },
-      manager: {
-        type: String,
-        required: false,
-      },
-      startCommand: {
-        type: String,
-        required: false,
-      },
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IFramework>("Framework", frameworkSchema, "frameworks");

package/index.ts

@@ -1,199 +0,0 @@
-export { default as User } from "./user";
-export { default as Project, DeletedProject } from "./project";
-export { default as ProjectAnalytics } from "./project_analytics";
-export { default as Preview } from "./project/preview";
-export { default as ProjectConnection } from "./project/connection";
-export { default as Following } from "./following";
-export { default as Integration } from "./integration";
-export { default as Domain } from "./domain";
-export { default as Dns } from "./domain/dns";
-export { default as Env } from "./env";
-export { default as Token } from "./token";
-export { default as Team } from "./team";
-export { default as Member } from "./member";
-export { default as Permission } from "./permission";
-export { default as MemberPermission } from "./member-permission";
-export { default as Role } from "./role";
-export { default as Log } from "./logs";
-export { default as Subscription } from "./subscription";
-export { default as Card } from "./card";
-export { default as Server } from "./server";
-export { default as Wallet } from "./wallet";
-export { default as DbImage } from "./db-image";
-export { default as Job } from "./job";
-export { default as Liscense } from "./license";
-export { default as PlanConfiguration } from "./plan_configuration";
-export { default as AutoScalingGroup } from "./auto-scaling";
-export { default as ComputeChange } from "./compute";
-export { default as Region } from "./region";
-export { default as Volume } from "./volume";
-export { default as Framework } from "./framework";
-export { default as Settings } from "./settings";
-export { default as LoadBalancerPort } from "./load-balancer-port";
-export { default as DomainRenewal } from "./domain/renewal";
-export { default as DomainTransfer } from "./domain/transfer";
-export { default as WebhookCategory } from "./webhook-category";
-export { default as WebhookEvent } from "./webhook-event";
-export { default as WebhookSetting } from "./webhook-setting";
-export { default as Intention } from "./intention";
-export { default as Provider } from "./provider";
-export { default as CollabAnnotation } from "./collab-annotation";
-export { default as CollabComment } from "./collab-comment";
-export { default as CollabIntegration } from "./collab-integration";
-export { default as CollabSettings } from "./collab-settings";
-export { default as CollabShareToken } from "./collab-share-token";
-export { default as CollabPushSubscription } from "./collab-push-subscription";
-export { default as AppMessage } from "./app-message";
-export { default as Invoice } from "./invoice";
-export { default as Tag } from "./tag";
-export { default as ProjectTagAssignment } from "./project-tag-assignment";
-export { default as CashierSubscription } from "./cashier_subscription";
-export { default as CashierSubscriptionItem } from "./cashier_subscription_item";
-export { default as ProjectEnvironment } from "./project-environment";
-export { default as EnvironmentVariable } from "./environment-variable";
-export { default as ActivityLog } from "./activity-log";
-export { default as OwnershipTransfer } from "./ownership-transfer";
-
-export {
-  IUser,
-  IGit,
-  IProject,
-  IProjectAnalytics,
-  IPreview,
-  IProjectConnection,
-  IFollowing,
-  IIntegration,
-  IEnv,
-  IServer,
-  IDomain,
-  IToken,
-  IMember,
-  ITeam,
-  IInstalledIntegration,
-  ILog,
-  ISubscription,
-  ICard,
-  IDns,
-  IRole,
-  IPermission,
-  IMemberPermission,
-  IWallet,
-  IDbImage,
-  IJob,
-  ILicense,
-  IPlanConfiguration,
-  IAutoScalingGroup,
-  IComputeChange,
-  IRegion,
-  IVolume,
-  IFramework,
-  BrimbleFrameworkType,
-  ISettings,
-  ILoadBalancerPort,
-  IDomainRenewal,
-  IDomainTransfer,
-  IWebhookCategory,
-  IWebhookEvent,
-  IWebhookSetting,
-  IIntention,
-  IProvider,
-  ICollabAnnotation,
-  ICollabComment,
-  ICollabAttachment,
-  ICollabIntegration,
-  ICollabSettings,
-  ICollabShareToken,
-  ICollabPushSubscription,
-  IAppMessage,
-  IInvoice,
-  ITag,
-  IProjectTagAssignment,
-  ICashierSubscription,
-  ICashierSubscriptionItem,
-  IProjectEnvironment,
-  IEnvironmentVariable,
-  IActivityLog,
-  IOwnershipTransfer,
-} from "./types";
-export {
-  GIT_TYPE,
-  INTEGRATION_TYPES,
-  INTEGRATION_PROVIDERS,
-  OAUTH_PERMISSIONS,
-  ENVIRONMENT,
-  SERVER_STATUS,
-  ROLES,
-  SUBSCRIPTION_PLAN_TYPE,
-  PROJECT_STATUS,
-  SUBSCRIPTION_STATUS,
-  CARD_TYPES,
-  DNS_TYPE,
-  PERMISSION_TYPE,
-  REQUEST_TYPE,
-  ServiceType,
-  DatabaseEngine,
-  JobStatus,
-  LicenseStatus,
-  REGION_CONTINENT,
-  BUILD_DISABLED_BY,
-  SERVER_PROTOCOL,
-  FrameworkApplicationType,
-  DomainRenewalStatus,
-  DomainTransferProvider,
-  DomainTransferDirection,
-  DomainTransferStatus,
-  NomadDeploymentStatus,
-  COLLAB_ANNOTATION_STATUS,
-  COLLAB_INTEGRATION_TYPE,
-  COLLAB_THEME,
-  COLLAB_TOOLBAR_POSITION,
-  INVOICE_STATUS,
-  INVOICE_PAYMENT_STATUS,
-  INVOICE_TYPE
-} from "./enum";
-
-import mongoose from "mongoose";
-import { log } from "@brimble/utils";
-
-export const connectToMongo = async (
-  mongoUrl: string,
-  config?: mongoose.ConnectOptions,
-): Promise<void> => {
-  const options: mongoose.ConnectOptions = {
-    socketTimeoutMS: 30000,
-    maxPoolSize: 10,
-    ...config,
-  };
-
-  mongoose.connect(mongoUrl, options).catch((err) => {
-    log.error(`Unable to connect to mongo db, ${err}`);
-  });
-
-  // listen for connection
-  mongoose.connection.on("connected", () => {
-    console.log("Database connection successful 🚀");
-  });
-
-  // listen for error
-  mongoose.connection.on("error", ({ message }) => {
-    log.error(`Error connecting to DB`, message);
-    return process.exit(1);
-  });
-};
-
-export const db = mongoose.connection;
-
-export const closeMongo = () => mongoose.connection.close(true);
-
-export const healthCheckMongo = async (): Promise<boolean> => {
-  try {
-    if (mongoose.connection.readyState !== 1) {
-      return false;
-    }
-    await mongoose.connection.db.admin().ping();
-    return true;
-  } catch (error) {
-    log.error(`MongoDB health check failed`, error);
-    return false;
-  }
-};

package/integration.ts

@@ -1,39 +0,0 @@
-import { model, Schema } from "mongoose";
-import { INTEGRATION_PROVIDERS, INTEGRATION_TYPES } from "./enum";
-import { IIntegration } from "./types";
-
-const integrationSchema: Schema = new Schema(
-  {
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      default: null,
-      required: true,
-    },
-    team_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      default: null,
-      required: false,
-    },
-    name: {
-      type: String,
-      enum: Object.values(INTEGRATION_PROVIDERS),
-      required: true,
-    },
-    app_id: String,
-    hook: String,
-    scope_description: Array,
-    reference: String,
-    type: {
-      type: String,
-      enum: Object.values(INTEGRATION_TYPES),
-      required: true,
-    },
-    token: String,
-    extra: Object,
-  },
-  { timestamps: true },
-);
-
-export default model<IIntegration>("Integration", integrationSchema);

package/intention.ts

@@ -1,40 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IIntention } from "./types";
-
-const intentionSchema = new Schema(
-  {
-    project: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-      required: true,
-    },
-    sourceName: {
-      type: String,
-      required: true,
-    },
-    destinationName: {
-      type: String,
-      required: true,
-    },
-    sourceNamespace: {
-      type: String,
-      default: "default",
-    },
-    destinationNamespace: {
-      type: String,
-      default: "default",
-    },
-    action: {
-      type: String,
-      enum: ["allow", "deny"],
-      default: "allow",
-    },
-    description: {
-      type: String,
-      required: false,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IIntention>("Intention", intentionSchema);

package/invoice.ts

@@ -1,36 +0,0 @@
-import { model, Schema } from "mongoose";
-import {
-  INVOICE_STATUS,
-  INVOICE_PAYMENT_STATUS,
-  INVOICE_TYPE,
-} from "./enum";
-import { IInvoice } from "./types";
-
-const invoiceSchema: Schema = new Schema(
-  {
-    ref: String,
-    user_id: String,
-    subscription_id: String,
-    total_amount: Number,
-    due: Boolean,
-    type: {
-      type: String,
-      enum: Object.values(INVOICE_TYPE),
-    },
-    status: {
-      type: String,
-      enum: Object.values(INVOICE_STATUS),
-    },
-    payment_status: {
-      type: String,
-      enum: Object.values(INVOICE_PAYMENT_STATUS),
-    },
-    billing_period: String,
-  },
-  {
-    timestamps: true,
-    collection: "invoices",
-  },
-);
-
-export default model<IInvoice>("Invoice", invoiceSchema);

package/job.ts

@@ -1,30 +0,0 @@
-import mongoose, { model, Schema } from "mongoose";
-import { IJob } from "./types/job";
-import { JobStatus } from "./enum";
-
-const jobSchema: Schema = new Schema({
-  title: { type: String, required: true },
-  jobId: { type: String, required: true, unique: true },
-  url: { type: String, required: true },
-  method: { type: String, required: true },
-  schedule: { type: String, required: true },
-  headers: { type: Map, of: String },
-  maxAttempts: { type: Number, default: 5 },
-  attempts: { type: Number, default: 0 },
-  isRecurring: { type: Boolean, required: true },
-  lastRun: Date,
-  nextRun: Date,
-  body: {
-    type: mongoose.Schema.Types.Mixed,
-    required: false,
-  },
-  status: {
-    type: String,
-    enum: Object.values(JobStatus),
-    default: JobStatus.SCHEDULED,
-  },
-  createdAt: { type: Date, default: Date.now },
-  updatedAt: { type: Date, default: Date.now },
-});
-
-export default model<IJob>("Job", jobSchema, "scheduled_jobs");

package/load-balancer-port.ts

@@ -1,31 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ILoadBalancerPort } from "./types";
-
-const loadBalancerPortSchema = new Schema(
-  {
-    port: {
-      type: Number,
-      required: true,
-      min: 1,
-      max: 65535,
-    },
-    server_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Server",
-      required: true,
-    },
-    project_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Project",
-      required: true,
-    },
-    region_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Region",
-      required: true,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<ILoadBalancerPort>("LoadBalancerPort", loadBalancerPortSchema, "load_balancer_ports");

package/logs.ts

@@ -1,47 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ENVIRONMENT, PROJECT_STATUS } from "./enum";
-import { ILog } from "./types";
-import { softDeletePlugin } from "soft-delete-plugin-mongoose";
-
-const LogSchema = new Schema(
-  {
-    name: String,
-    key: String,
-    commit: Object,
-    status: {
-      type: String,
-      enum: Object.values(PROJECT_STATUS),
-      default: PROJECT_STATUS.PENDING,
-    },
-    project: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-    },
-    user: {
-      ref: "User",
-      type: Schema.Types.ObjectId,
-    },
-    team: {
-      ref: "Team",
-      type: Schema.Types.ObjectId,
-    },
-    preview: {
-      ref: "Preview",
-      type: Schema.Types.ObjectId,
-    },
-    environment: {
-      type: String,
-      enum: Object.values(ENVIRONMENT),
-      default: ENVIRONMENT.PRODUCTION,
-    },
-    jobs: Array,
-    startTime: Schema.Types.Date,
-    endTime: Schema.Types.Date,
-    deleted: Schema.Types.Boolean,
-  },
-  { timestamps: true },
-);
-
-LogSchema.plugin(softDeletePlugin);
-
-export default model<ILog>("Log", LogSchema);

package/member-permission.ts

@@ -1,13 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IMemberPermission } from "./types/member-permission";
-
-const memberPermissionSchema = new Schema({
-  permission: { type: Schema.Types.ObjectId, ref: "Permission" },
-  member: { type: Schema.Types.ObjectId, ref: "Member" },
-  enabled: { type: Boolean, default: false },
-});
-
-export default model<IMemberPermission>(
-  "MemberPermission",
-  memberPermissionSchema,
-);

package/member.ts

@@ -1,44 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ROLES } from "./enum";
-import { IMember } from "./types";
-
-const memberSchema: Schema = new Schema(
-  {
-    user: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-    },
-    email: String,
-    team: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-    },
-    role: {
-      type: String,
-      enum: Object.values(ROLES),
-      default: ROLES.MEMBER,
-    },
-    accepted: {
-      type: Boolean,
-      default: false,
-    },
-    invitedBy: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-    },
-    featureOnboarded: {
-      type: Boolean,
-      default: false,
-    },
-    permissions: [{ type: Schema.Types.ObjectId, ref: "MemberPermission" }],
-    project_environments: [{ type: Schema.Types.ObjectId, ref: "ProjectEnvironment" }],
-  },
-  {
-    timestamps: {
-      createdAt: "created_at",
-      updatedAt: "updated_at",
-    },
-  },
-);
-
-export default model<IMember>("Member", memberSchema);