@brimble/models 3.8.77 → 3.8.79

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/plan_configuration.ts

@@ -1,48 +0,0 @@
-import mongoose, { Schema, Document, model } from "mongoose";
-import { SUBSCRIPTION_PLAN_TYPE } from "./enum";
-import { IPlanConfiguration } from "./types/plan_configuration";
-
-const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
-  {
-    tag: { type: String, required: true },
-    slack_support: { type: Boolean, default: false },
-    concurrent_builds: { type: Number, required: true },
-    project_limit: { type: Number, required: true },
-    deploy_private_organization: { type: Boolean, default: false },
-    preview_comments: { type: Boolean, default: false },
-    analytics: { type: Boolean, default: false },
-    build_minutes: { type: Number, required: true },
-    pull_request_preview: { type: Boolean, default: false, required: false },
-    log_retention: { type: Number, required: true },
-    bandwidth: { type: Number, required: true },
-    price: { type: Number, required: true },
-    autoscaling_enabled: { type: Boolean, default: false, required: false },
-    region: { type: Schema.Types.ObjectId, ref: "Region", required: false },
-    multi_region: { type: Boolean, default: false },
-    unlimited_projects: { type: Boolean, default: false },
-    plan_type: {
-      type: String,
-      enum: Object.values(SUBSCRIPTION_PLAN_TYPE),
-      required: true,
-    },
-    memory: { type: Number, required: true },
-    build_timeout: { type: Number, required: true },
-    storage: { type: Number, required: true },
-    cpu: { type: Number, required: true },
-    tokens: { type: Number, required: false },
-    hierarchy: { type: Number, required: false },
-    token_request: { type: Number, required: false },
-    view_metrics: { type: Boolean, required: false, default: false },
-    custom_domain: { type: Boolean, required: true, default: false },
-    webhook_enabled: { type: Boolean, required: true, default: false },
-    can_deploy_all_applications: { type: Boolean, required: true, default: false },
-    stripe_prices: { type: Schema.Types.Mixed, required: false, default: {} },
-  },
-  { timestamps: true },
-);
-
-export default model<IPlanConfiguration>(
-  "PlanConfigurations",
-  PlanConfigurationSchema,
-  "plan_configurations",
-);

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,238 +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,
-    },
-    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,
-    },
-    volumeMount: {
-      type: String,
-      required: false,
-    },
-  },
-  { timestamps: true },
-);
-
-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);

package/server.ts

@@ -1,105 +0,0 @@
-import { model, Schema } from "mongoose";
-import { IServer } from "./types";
-import { SERVER_STATUS, SERVER_PROTOCOL } from "./enum";
-
-const serverSchema = new Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-    },
-    url: String,
-    grpc_address: String,
-    userId: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-    },
-    teamId: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      required: false,
-    },
-    domain: {
-      required: false,
-      type: String,
-    },
-    webhook_url: String,
-    ip_address: {
-      type: String,
-      required: true,
-    },
-    ipv6: String,
-    private_ip_address: {
-      type: String,
-      required: true,
-    },
-    tunnel_token: {
-      type: String,
-      required: false,
-    },
-    type: String,
-    status: {
-      type: String,
-      enum: Object.values(SERVER_STATUS),
-      default: SERVER_STATUS.Active,
-    },
-    protocol: {
-      type: String,
-      enum: Object.values(SERVER_PROTOCOL),
-      default: SERVER_PROTOCOL.TCP,
-    },
-    default: Boolean,
-    is_custom_provision: {
-      type: Boolean,
-      default: true,
-    },
-    region: {
-      type: Schema.Types.ObjectId,
-      ref: "Region",
-      required: true,
-    },
-    tag: String,
-    plugin_id: {
-      type: String,
-      required: false,
-    },
-    firewall_id: {
-      required: false,
-      type: String,
-    },
-    provider: {
-      type: String,
-      required: true,
-    },
-    provider_location: {
-      type: String,
-      required: false,
-    },
-    provider_identifier: {
-      type: String,
-      required: false,
-    },
-    topology_path: {
-      type: String,
-      required: false,
-    },
-    specifications: {
-      type: Object,
-      default: {},
-      select: true,
-    },
-    cert_storage_path: {
-      type: String,
-      required: false,
-    },
-    meta: {
-      type: Object,
-      default: {},
-      select: true,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<IServer>("Server", serverSchema);

package/settings.ts

@@ -1,53 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISettings } from "./types";
-
-const settingsSchema: Schema = new Schema(
-    {
-        vaultEnabled: {
-            type: Boolean,
-            default: false,
-        },
-        maintenanceMode: {
-            type: Boolean,
-            default: false,
-        },
-        enableSecretRotation: {
-            type: String,
-            required: false,
-        },
-        domainPromoEnabled: {
-            type: Boolean,
-            default: false,
-        },
-        buildsEnabled: {
-            type: Boolean,
-            default: false,
-        },
-        minimumBuildMinutes: {
-            type: Number,
-            required: false,
-        },
-        enableLogging: {
-            type: Boolean,
-            default: false,
-        },
-        postHogEnabled: {
-            type: Boolean,
-            default: false
-        },
-        webhookEnabled: {
-            type: Boolean,
-            default: false,
-        },
-        metaSettings: {
-            type: Object,
-            required: false,
-        },
-    },
-    {
-        timestamps: true,
-        collection: "app_settings",
-    },
-);
-
-export default model<ISettings>("Settings", settingsSchema, "app_settings");