@brimble/models 3.8.45 → 3.8.47

package/sandbox-activity.ts

@@ -1,53 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandboxActivity } from "./types/sandbox-activity";
-
-const sandboxActivitySchema: Schema = new Schema(
-  {
-    sandbox_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Sandbox",
-      required: true,
-      index: true,
-    },
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    team: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      default: null,
-      index: true,
-    },
-    command: {
-      type: String,
-      required: true,
-    },
-    started_at: {
-      type: Date,
-      required: true,
-      index: true,
-    },
-    ended_at: {
-      type: Date,
-      default: null,
-    },
-    exit_code: {
-      type: Number,
-      default: null,
-    },
-    duration_ms: {
-      type: Number,
-      default: null,
-    },
-    error: {
-      type: String,
-      default: null,
-    },
-  },
-  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } },
-);
-
-export default model<ISandboxActivity>("SandboxActivity", sandboxActivitySchema);

package/sandbox-image.ts

@@ -1,35 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandboxImage } from "./types/sandbox-image";
-
-const sandboxImageSchema = new Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-      unique: true,
-    },
-    display_name: {
-      type: String,
-      required: true,
-    },
-    image: {
-      type: String,
-      required: true,
-    },
-    description: {
-      type: String,
-      required: true,
-    },
-    is_available: {
-      type: Boolean,
-      default: true,
-    },
-    is_default: {
-      type: Boolean,
-      default: false,
-    },
-  },
-  { timestamps: true },
-);
-
-export default model<ISandboxImage>("SandboxImage", sandboxImageSchema);

package/sandbox-snapshot-usage-segment.ts

@@ -1,61 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandboxSnapshotUsageSegment } from "./types/sandbox-snapshot-usage-segment";
-
-const sandboxSnapshotUsageSegmentSchema = new Schema<ISandboxSnapshotUsageSegment>(
-  {
-    snapshot_id: {
-      type: Schema.Types.ObjectId,
-      ref: "SandboxSnapshot",
-      required: true,
-      index: true,
-    },
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    team_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      required: false,
-      default: null,
-      index: true,
-    },
-    size_gb: {
-      type: Number,
-      required: true,
-      default: 0,
-    },
-    costs: {
-      startDate: { type: Date, required: true },
-      endDate: { type: Date, default: null },
-    },
-    billed: {
-      type: Boolean,
-      default: false,
-      index: true,
-    },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-sandboxSnapshotUsageSegmentSchema.index({ user_id: 1, billed: 1, "costs.endDate": 1 });
-sandboxSnapshotUsageSegmentSchema.index({ team_id: 1, billed: 1, "costs.endDate": 1 });
-sandboxSnapshotUsageSegmentSchema.index({ snapshot_id: 1, "costs.endDate": 1 });
-sandboxSnapshotUsageSegmentSchema.index(
-  { snapshot_id: 1 },
-  {
-    unique: true,
-    partialFilterExpression: { "costs.endDate": null },
-    name: "unique_open_segment_per_snapshot",
-  },
-);
-
-export default model<ISandboxSnapshotUsageSegment>(
-  "SandboxSnapshotUsageSegment",
-  sandboxSnapshotUsageSegmentSchema,
-  "sandbox_snapshot_usage_segments",
-);

package/sandbox-snapshot.ts

@@ -1,55 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandboxSnapshot } from "./types/sandbox-snapshot";
-import { SANDBOX_SNAPSHOT_STATUS } from "./enum";
-
-const sandboxSnapshotSchema: Schema = new Schema(
-  {
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    team: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      default: null,
-      index: true,
-    },
-    sandbox_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Sandbox",
-      required: true,
-      index: true,
-    },
-    name: {
-      type: String,
-      required: true,
-      match: /^[a-z0-9-]{1,40}$/,
-    },
-    image_tag: {
-      type: String,
-      required: true,
-    },
-    source_template: {
-      type: String,
-      required: true,
-    },
-    status: {
-      type: String,
-      enum: Object.values(SANDBOX_SNAPSHOT_STATUS),
-      default: SANDBOX_SNAPSHOT_STATUS.CREATING,
-    },
-    failure_reason: {
-      type: String,
-      default: null,
-    },
-    size_bytes: {
-      type: Number,
-      default: null,
-    },
-  },
-  { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } },
-);
-
-export default model<ISandboxSnapshot>("SandboxSnapshot", sandboxSnapshotSchema);

package/sandbox-usage-segment.ts

@@ -1,69 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandboxUsageSegment } from "./types/sandbox-usage-segment";
-
-const sandboxUsageSegmentSchema = new Schema<ISandboxUsageSegment>(
-  {
-    sandbox_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Sandbox",
-      required: true,
-      index: true,
-    },
-    user_id: {
-      type: Schema.Types.ObjectId,
-      ref: "User",
-      required: true,
-      index: true,
-    },
-    team_id: {
-      type: Schema.Types.ObjectId,
-      ref: "Team",
-      required: false,
-      index: true,
-      default: null,
-    },
-    current: {
-      cpu: { type: Number, required: true },
-      memory: { type: Number, required: true },
-      storage: { type: Number, required: true },
-    },
-    costs: {
-      startDate: { type: Date, required: true },
-      endDate: { type: Date, default: null },
-    },
-    billed: {
-      type: Boolean,
-      default: false,
-      index: true,
-    },
-    region: {
-      type: String,
-      required: false,
-    },
-    template: {
-      type: String,
-      required: false,
-    },
-  },
-  {
-    timestamps: true,
-  },
-);
-
-sandboxUsageSegmentSchema.index({ user_id: 1, billed: 1, "costs.endDate": 1 });
-sandboxUsageSegmentSchema.index({ team_id: 1, billed: 1, "costs.endDate": 1 });
-sandboxUsageSegmentSchema.index({ sandbox_id: 1, "costs.endDate": 1 });
-sandboxUsageSegmentSchema.index(
-  { sandbox_id: 1 },
-  {
-    unique: true,
-    partialFilterExpression: { "costs.endDate": null },
-    name: "uniq_open_sandbox_usage_segment_per_sandbox",
-  },
-);
-
-export default model<ISandboxUsageSegment>(
-  "SandboxUsageSegment",
-  sandboxUsageSegmentSchema,
-  "sandbox_usage_segments",
-);

package/sandbox.ts

@@ -1,134 +0,0 @@
-import { model, Schema } from "mongoose";
-import { ISandbox } from "./types/sandbox";
-import { SANDBOX_STATUS, SANDBOX_DESTROY_REASON } from "./enum";
-
-const sandboxSchema: Schema = new Schema({
-  name: {
-    type: String,
-    required: true
-  },
-  user_id: {
-    type: Schema.Types.ObjectId,
-    ref: "User",
-    required: true,
-  },
-  team: {
-    type: Schema.Types.ObjectId,
-    ref: "Team",
-    default: null,
-  },
-  project_environment: {
-    type: Schema.Types.ObjectId,
-    ref: "ProjectEnvironment",
-    default: null,
-  },
-  template: {
-    type: String,
-    required: true,
-  },
-  status: {
-    type: String,
-    enum: Object.values(SANDBOX_STATUS),
-    required: true,
-    default: SANDBOX_STATUS.STARTING,
-  },
-  nomad_job_id: {
-    type: String,
-    required: true,
-  },
-  nomad_alloc_id: {
-    type: String,
-    default: null,
-  },
-  region: {
-    type: Schema.Types.ObjectId,
-    ref: "Region",
-    required: true,
-  },
-  specs: {
-    cpu: { type: Number, default: 500 },
-    memory: { type: Number, default: 512 },
-    disk: { type: Number, default: 2 },
-  },
-  created_at: {
-    type: Date,
-    default: Date.now,
-  },
-  last_activity_at: {
-    type: Date,
-    default: Date.now,
-  },
-  expires_at: {
-    type: Date,
-    required: true,
-  },
-  destroyed_at: {
-    type: Date,
-    default: null,
-  },
-  destroy_reason: {
-    type: String,
-    enum: Object.values(SANDBOX_DESTROY_REASON),
-    default: null,
-  },
-  auto_destroy: {
-    type: Boolean,
-    default: false,
-  },
-  destroy_timeout: {
-    type: String,
-    default: null,
-  },
-  one_shot: {
-    type: Boolean,
-    default: false,
-  },
-  block_outbound: {
-    type: Boolean,
-    default: false,
-  },
-  persistent: {
-    type: Boolean,
-    default: false,
-  },
-  persistent_disk_gb: {
-    type: Number,
-    default: null,
-  },
-  csi_volume_id: {
-    type: String,
-    default: null,
-  },
-  paused_at: {
-    type: Date,
-    default: null,
-  },
-  image_override: {
-    type: String,
-    default: null,
-  },
-  from_snapshot: {
-    type: Schema.Types.ObjectId,
-    ref: "SandboxSnapshot",
-    default: null,
-  },
-  snapshot_mode: {
-    type: String,
-    enum: ["automatic", "manual"],
-    default: "manual",
-  },
-  snapshot_frequency: {
-    type: String,
-    default: null,
-  },
-  isDeleted: {
-    type: Boolean,
-    default: false,
-  },
-});
-
-sandboxSchema.index({ user_id: 1, status: 1, isDeleted: 1 });
-sandboxSchema.index({ expires_at: 1 });
-sandboxSchema.index({ last_activity_at: 1, status: 1 });
-
-export default model<ISandbox>("Sandbox", sandboxSchema);

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");

package/storage.ts

@@ -1,117 +0,0 @@
-import { model, Schema } from "mongoose";
-import {
-  StorageBucketStatus,
-  StorageCredentialRole,
-  StorageCredentialStatus,
-  StorageTokenStatus,
-  StorageUploadStatus,
-} from "./enum";
-import {
-  IStorageBucket,
-  IStorageCredential,
-  IStorageObject,
-  IStorageToken,
-  IStorageUpload,
-} from "./types/storage";
-
-const storageBucketSchema = new Schema(
-  {
-    name: { type: String, required: true, trim: true },
-    project: { type: Schema.Types.ObjectId, ref: "Project", required: false, index: true },
-    user_id: { type: Schema.Types.ObjectId, ref: "User", required: false, index: true },
-    team: { type: Schema.Types.ObjectId, ref: "Team", required: false, index: true },
-    bucket_name: { type: String, required: true, unique: true },
-    is_public: { type: Boolean, default: false },
-    versioning: { type: Boolean, default: false },
-    provider: { type: String, default: "tigris" },
-    region: { type: String, default: "auto" },
-    storage_used: { type: Number, default: 0 },
-    reserved_bytes: { type: Number, default: 0 },
-    quota: { type: Number, required: true },
-    status: { type: String, enum: Object.values(StorageBucketStatus), default: StorageBucketStatus.Active },
-  },
-  { timestamps: true },
-);
-
-storageBucketSchema.index({ user_id: 1, team: 1, name: 1 }, { unique: true, name: "uniq_storage_bucket_owner_name" });
-storageBucketSchema.index({ user_id: 1, updatedAt: -1 }, { name: "idx_storage_bucket_user_updated_at" });
-storageBucketSchema.index({ team: 1, updatedAt: -1 }, { name: "idx_storage_bucket_team_updated_at" });
-
-const storageObjectSchema = new Schema(
-  {
-    bucket: { type: Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
-    project: { type: Schema.Types.ObjectId, ref: "Project", required: false, index: true },
-    key: { type: String, required: true },
-    path: { type: String, required: true },
-    content_type: { type: String },
-    size: { type: Number, default: 0 },
-    etag: { type: String },
-    public_url: { type: String },
-    last_modified: { type: Date },
-  },
-  { timestamps: true },
-);
-
-storageObjectSchema.index({ bucket: 1, key: 1 }, { unique: true, name: "uniq_storage_object_bucket_key" });
-
-const storageUploadSchema = new Schema(
-  {
-    bucket: { type: Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
-    project: { type: Schema.Types.ObjectId, ref: "Project", required: false, index: true },
-    key: { type: String, required: true },
-    path: { type: String, required: true },
-    upload_id: { type: String, index: true },
-    content_type: { type: String },
-    size: { type: Number, required: true },
-    status: { type: String, enum: Object.values(StorageUploadStatus), default: StorageUploadStatus.Pending, index: true },
-    expires_at: { type: Date, required: true, index: true },
-    completed_at: { type: Date },
-  },
-  { timestamps: true },
-);
-
-const storageTokenSchema = new Schema(
-  {
-    name: { type: String, required: true, trim: true },
-    token_hash: { type: String, required: true, unique: true },
-    prefix: { type: String, required: true },
-    project: { type: Schema.Types.ObjectId, ref: "Project", required: false, index: true },
-    buckets: [{ type: Schema.Types.ObjectId, ref: "StorageBucket" }],
-    user_id: { type: Schema.Types.ObjectId, ref: "User", required: false, index: true },
-    team: { type: Schema.Types.ObjectId, ref: "Team", required: false, index: true },
-    permissions: [{ type: String, enum: ["read", "write", "delete", "list", "admin"], required: true }],
-    status: { type: String, enum: Object.values(StorageTokenStatus), default: StorageTokenStatus.Active },
-    last_used_at: { type: Date },
-    expires_at: { type: Date },
-  },
-  { timestamps: true },
-);
-
-storageTokenSchema.index({ project: 1, status: 1 }, { name: "idx_storage_token_project_status" });
-
-const storageCredentialSchema = new Schema(
-  {
-    name: { type: String, required: true, trim: true },
-    bucket: { type: Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
-    project: { type: Schema.Types.ObjectId, ref: "Project", required: false, index: true },
-    user_id: { type: Schema.Types.ObjectId, ref: "User", required: false, index: true },
-    team: { type: Schema.Types.ObjectId, ref: "Team", required: false, index: true },
-    provider: { type: String, default: "tigris" },
-    provider_org_id: { type: String, required: true },
-    access_key_id: { type: String, required: true, unique: true },
-    policy_names: [{ type: String }],
-    role: { type: String, enum: Object.values(StorageCredentialRole), required: true },
-    status: { type: String, enum: Object.values(StorageCredentialStatus), default: StorageCredentialStatus.Active, index: true },
-    last_rotated_at: { type: Date },
-    revoked_at: { type: Date },
-  },
-  { timestamps: true },
-);
-
-storageCredentialSchema.index({ bucket: 1, status: 1, updatedAt: -1 }, { name: "idx_storage_credential_bucket_status_updated_at" });
-
-export const StorageBucket = model<IStorageBucket>("StorageBucket", storageBucketSchema);
-export const StorageObject = model<IStorageObject>("StorageObject", storageObjectSchema);
-export const StorageUpload = model<IStorageUpload>("StorageUpload", storageUploadSchema);
-export const StorageToken = model<IStorageToken>("StorageToken", storageTokenSchema);
-export const StorageCredential = model<IStorageCredential>("StorageCredential", storageCredentialSchema);