@brimble/models 3.8.46 → 3.8.48

package/logs.ts

@@ -1,44 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ENVIRONMENT, PROJECT_STATUS } from "./enum";
-import { ILog } from "./types";
-
-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 },
-);
-
-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);

package/object-storage-usage-segment.ts

@@ -1,59 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IObjectStorageUsageSegment } from "./types/object-storage-usage-segment";
-
-const objectStorageUsageSegmentSchema = new Schema<IObjectStorageUsageSegment>(
-  {
-    bucket_id: {
-      type: Schema.Types.ObjectId,
-      ref: "StorageBucket",
-      required: true,
-    },
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    team_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      default: null,
-      index: true,
-    },
-    size_gb: {
-      type: Number,
-      default: 0,
-    },
-    costs: {
-      startDate: { type: Date, required: true },
-      endDate: { type: Date, default: null },
-    },
-    billed: {
-      type: Boolean,
-      default: false,
-      index: true,
-    },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-objectStorageUsageSegmentSchema.index({ user_id: 1, billed: 1, "costs.endDate": 1 });
-objectStorageUsageSegmentSchema.index({ team_id: 1, billed: 1, "costs.endDate": 1 });
-objectStorageUsageSegmentSchema.index({ bucket_id: 1, "costs.endDate": 1 });
-
-objectStorageUsageSegmentSchema.index(
-  { bucket_id: 1 },
-  {
-    unique: true,
-    partialFilterExpression: { "costs.endDate": null },
-    name: "unique_open_segment_per_object_storage_bucket",
-  },
-);
-
-export default model<IObjectStorageUsageSegment>(
-  "ObjectStorageUsageSegment",
-  objectStorageUsageSegmentSchema,
-  "object_storage_usage_segments",
-);

package/ownership-transfer.ts

@@ -1,42 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IOwnershipTransfer } from "./types";
-
-const ownershipTransferSchema: Schema = new Schema(
-  {
-    team: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      required: true,
-    },
-    from_user: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    to_user: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    status: {
-      type: String,
-      enum: ["pending", "accepted", "denied", "expired"],
-      default: "pending",
-    },
-    expires_at: {
-      type: Date,
-      required: true,
-    },
-  },
-  {
-    timestamps: {
-      createdAt: "created_at",
-      updatedAt: "updated_at",
-    },
-  },
-);
-
-export default model<IOwnershipTransfer>(
-  "OwnershipTransfer",
-  ownershipTransferSchema,
-);

package/permission.ts

@@ -1,13 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IPermission } from "./types/permission";
-import { PERMISSION_TYPE } from "./enum";
-
-const permissionSchema = new Schema({
-  title: { type: String },
-  role: [{ type: Schema.Types.ObjectId, ref: "Role" }],
-  request: { type: Object },
-  type: { type: String, enum: Object.values(PERMISSION_TYPE) },
-  enabled: { type: Boolean, default: false, select: true },
-});
-
-export default model<IPermission>("Permission", permissionSchema);

package/project/connection.ts

@@ -1,21 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IProjectConnection } from "../types";
-
-const projectConnectionSchema = new Schema(
-  {
-    service: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-    },
-    project: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IProjectConnection>(
-  "ProjectConnection",
-  projectConnectionSchema,
-);

package/project/index.ts

@@ -1,264 +0,0 @@
-import { model, Schema } from "mongoose";
-import { PROJECT_STATUS, ServiceType } from "../enum";
-import { IProject } from "../types";
-
-const projectSchema = new Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-      unique: true,
-    },
-    uuid: Number,
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: false,
-    },
-    monitor_id: {
-      type: String,
-      required: false,
-    },
-    healthCheckPath: {
-      type: String,
-      required: false,
-    },
-    preStartCommand: {
-      type: String,
-      required: false,
-    },
-    buildCacheEnabled: {
-      type: Boolean,
-      default: true,
-    },
-    domains: [
-      {
-        ref: "Domain",
-        type: Schema.Types.ObjectId,
-      },
-    ],
-    environments: [
-      {
-        ref: "Env",
-        type: Schema.Types.ObjectId,
-      },
-    ],
-    team: {
-      ref: "Team",
-      type: Schema.Types.ObjectId,
-    },
-    watchPaths: {
-      type: Array,
-      required: false,
-      default: [],
-    },
-    server: {
-      ref: "Server",
-      type: Schema.Types.ObjectId,
-    },
-    deployedInCluster: {
-      type: Boolean,
-      default: false,
-    },
-    pid: Number,
-    port: Number,
-    ip: String,
-    dir: String,
-    installCommand: String,
-    buildCommand: String,
-    startCommand: String,
-    outputDirectory: String,
-    repo: Object,
-    rootDir: String,
-    isPrivate: {
-      type: Boolean,
-      default: false,
-    },
-    tlsEnabled: {
-      type: Boolean,
-      default: false
-    },
-    status: {
-      type: String,
-      enum: Object.values(PROJECT_STATUS),
-      default: PROJECT_STATUS.PENDING,
-    },
-    framework: String,
-    description: String,
-    logs: [
-      {
-        ref: "Log",
-        type: Schema.Types.ObjectId,
-      },
-    ],
-    log: {
-      ref: "Log",
-      type: Schema.Types.ObjectId,
-    },
-    maintenance: {
-      type: Boolean,
-      default: false,
-    },
-    passwordEnabled: {
-      type: Boolean,
-      default: false,
-    },
-    backupEnabled: {
-      type: Boolean,
-      default: false,
-    },
-    free_tier_expires_at: {
-      type: Date,
-      default: null,
-    },
-    free_tier_expiry_notified_at: {
-      type: Date,
-      default: null,
-    },
-    disabled: {
-      type: Boolean,
-      default: false,
-    },
-    password: {
-      type: String,
-      default: null,
-    },
-    screenshot: {
-      image: String,
-      public_id: String,
-    },
-    hasUpdates: {
-      type: Boolean,
-      default: false,
-    },
-    lastProcessed: Number,
-    tracking_token: String,
-    from: Schema.Types.ObjectId,
-    container_stats_schedule_id: {
-      type: String,
-      default: null,
-    },
-    previews: [
-      {
-        ref: "Preview",
-        type: Schema.Types.ObjectId,
-      },
-    ],
-    project_environment: {
-      ref: "ProjectEnvironment",
-      type: Schema.Types.ObjectId,
-      index: true,
-    },
-    inherit_environment_vars: {
-      type: Boolean,
-      default: true,
-    },
-    replicas: {
-      type: Number,
-      default: 3,
-    },
-    nomadJobId: String,
-    specs: {
-      memory: {
-        type: Number,
-        default: 0.5,
-      },
-      cpu: {
-        type: Number,
-        default: 0.2,
-      },
-      storage: {
-        type: Number,
-        default: 1,
-      },
-      region: {
-        type: Schema.Types.ObjectId,
-        ref: "Region",
-        required: true,
-      },
-    },
-    last_requested: Schema.Types.Date,
-    isPaused: Boolean,
-    dbImage: {
-      ref: "DbImage",
-      type: Schema.Types.ObjectId,
-      required: false,
-    },
-    serviceType: {
-      type: String,
-      enum: Object.values(ServiceType),
-      default: ServiceType.WebService,
-    },
-    billable: {
-      type: Boolean,
-      default: false,
-    },
-    isPaid: {
-      type: Boolean,
-      default: false,
-    },
-    diskSize: {
-      type: Number,
-      default: 0,
-    },
-    authEnabled: {
-      type: Boolean,
-      default: false,
-    },
-    last_backup_url: {
-      type: String,
-      default: null,
-    },
-    last_backup_at: {
-      type: Date,
-      default: null,
-    },
-    replica_ready: {
-      type: Boolean,
-      default: false,
-    },
-    autoscaling_group: {
-      ref: "AutoScalingGroup",
-      type: Schema.Types.ObjectId,
-      required: false,
-    },
-    whiteListedIps: {
-      type: Array,
-      required: false,
-    },
-    vaultPath: {
-      type: String,
-      default: null,
-    },
-    vaultToken: {
-      type: String,
-      default: null,
-    },
-    persistent_mount_path: {
-      type: String,
-      required: false
-    },
-    volumeMount: {
-      type: String,
-      required: false,
-    },
-    volume: {
-      type: Schema.Types.ObjectId,
-      ref: "Volume",
-      default: null,
-    },
-  },
-  { timestamps: true },
-);
-
-projectSchema.index(
-  { free_tier_expires_at: 1, serviceType: 1, status: 1 },
-  {
-    partialFilterExpression: { free_tier_expires_at: { $type: "date" } },
-    name: "free_tier_lifecycle",
-  },
-);
-
-export default model<IProject>("Project", projectSchema);
-
-export const DeletedProject = model<IProject>("DeletedProject", projectSchema);

package/project/preview.ts

@@ -1,41 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IPreview } from "../types";
-import { PROJECT_STATUS } from "../enum";
-
-const previewsSchema = new Schema(
-  {
-    name: String,
-    project: {
-      ref: "Project",
-      type: Schema.Types.ObjectId,
-    },
-    server: {
-      ref: "Server",
-      type: Schema.Types.ObjectId,
-    },
-    healthCheckPath: {
-      type: String,
-      required: false,
-    },
-    pid: Number,
-    port: Number,
-    ip: String,
-    dir: String,
-    branch: String,
-    issue_comment_id: Number,
-    status: {
-      type: String,
-      enum: Object.values(PROJECT_STATUS),
-      default: PROJECT_STATUS.PENDING,
-    },
-    log: {
-      ref: "Log",
-      type: Schema.Types.ObjectId,
-    },
-    last_requested: Schema.Types.Date,
-    isPaused: Boolean,
-  },
-  { timestamps: true },
-);
-
-export default model<IPreview>("Preview", previewsSchema);

package/project-environment.ts

@@ -1,18 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IProjectEnvironment } from "./types";
-
-const projectEnvironmentSchema = new Schema(
-  {
-    name: { type: String, required: true },
-    slug: { type: String, required: true },
-    owner: { ref: "User", type: Schema.Types.ObjectId, required: true },
-    team: { ref: "Team", type: Schema.Types.ObjectId },
-    inherit_from: { ref: "ProjectEnvironment", type: Schema.Types.ObjectId },
-    isDefault: { type: Boolean, default: false },
-  },
-  { timestamps: true },
-);
-
-projectEnvironmentSchema.index({ slug: 1, owner: 1, team: 1 }, { unique: true });
-
-export default model<IProjectEnvironment>("ProjectEnvironment", projectEnvironmentSchema);

package/project-tag-assignment.ts

@@ -1,40 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IProjectTagAssignment } from "./types";
-
-const projectTagAssignmentSchema: Schema = new Schema(
-  {
-    tagId: {
-      type: Schema.Types.ObjectId,
-      ref: "Tag",
-      required: true,
-    },
-    projectId: {
-      type: Schema.Types.ObjectId,
-      ref: "Project",
-      required: true,
-    },
-    teamId: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      default: null,
-    },
-    assignedBy: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-  },
-  {
-    timestamps: true,
-    collection: "project_tag_assignments",
-  },
-);
-
-projectTagAssignmentSchema.index({ tagId: 1, projectId: 1 }, { unique: true });
-projectTagAssignmentSchema.index({ projectId: 1 });
-projectTagAssignmentSchema.index({ teamId: 1 });
-
-export default model<IProjectTagAssignment>(
-  "ProjectTagAssignment",
-  projectTagAssignmentSchema,
-);

package/project_analytics.ts

@@ -1,26 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IProjectAnalytics } from "./types/project_analytics";
-
-const ProjectAnalyticsSchema = new Schema<IProjectAnalytics>(
-  {
-    project: {
-      type: Schema.Types.ObjectId,
-      ref: "Project",
-      required: true,
-      unique: true,
-      index: true,
-    },
-    provider: { type: String, enum: ["umami"], required: true, default: "umami" },
-    websiteId: { type: String, required: true, unique: true },
-    shareId: { type: String, default: null },
-    domain: { type: String, required: true },
-    enabled: { type: Boolean, default: true },
-  },
-  { timestamps: true },
-);
-
-export default model<IProjectAnalytics>(
-  "ProjectAnalytics",
-  ProjectAnalyticsSchema,
-  "project_analytics",
-);

package/provider.ts

@@ -1,11 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IProvider } from "./types/provider";
-
-const providerSchema = new Schema({
-  name: { type: String, required: true },
-  slug: { type: String, required: true, unique: true },
-  logo: { type: String, required: true },
-  enabled: { type: Boolean, default: true },
-});
-
-export default model<IProvider>("Provider", providerSchema, "providers");

package/region.ts

@@ -1,18 +0,0 @@
-import { Schema, model } from "mongoose";
-import { IRegion } from "./types/region";
-import { REGION_CONTINENT } from "./enum";
-
-const regionSchema = new Schema({
-  name: { type: String, required: true },
-  country: { type: String, required: true },
-  continent: { type: String, enum: Object.values(REGION_CONTINENT) },
-  enabled: { type: Boolean, default: false, select: true },
-  dbVolumePath: { type: String, required: true },
-  is_paid: { type: Boolean, default: false },
-  provider: { type: String, required: true },
-  provider_identifier: { type: String, required: true },
-  storage_pricing_factor: { type: Number, required: true, default: 0.25 },
-  floating_ip: { type: String },
-});
-
-export default model<IRegion>("Region", regionSchema, "regions");

package/role.ts

@@ -1,12 +0,0 @@
-import { Schema, model } from "mongoose";
-import { ROLES } from "./enum";
-import { IRole } from "./types/role";
-
-const roleSchema = new Schema({
-  type: { type: String, enum: Object.values(ROLES) },
-  description: { type: String },
-  is_custom: { type: Boolean, default: false },
-  permissions: [{ type: Schema.Types.ObjectId, ref: "Permission" }],
-});
-
-export default model<IRole>("Role", roleSchema);