@brimble/models 3.8.45 → 3.8.47

package/dist/sandbox-snapshot.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const sandboxSnapshotSchema = new mongoose_1.Schema({
+    user_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+        index: true,
+    },
+    team: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+        default: null,
+        index: true,
+    },
+    sandbox_id: {
+        type: mongoose_1.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(enum_1.SANDBOX_SNAPSHOT_STATUS),
+        default: enum_1.SANDBOX_SNAPSHOT_STATUS.CREATING,
+    },
+    failure_reason: {
+        type: String,
+        default: null,
+    },
+    size_bytes: {
+        type: Number,
+        default: null,
+    },
+}, { timestamps: { createdAt: "created_at", updatedAt: "updated_at" } });
+exports.default = (0, mongoose_1.model)("SandboxSnapshot", sandboxSnapshotSchema);

package/dist/sandbox-usage-segment.d.ts

@@ -0,0 +1,9 @@
+import { ISandboxUsageSegment } from "./types/sandbox-usage-segment";
+declare const _default: import("mongoose").Model<ISandboxUsageSegment, {}, {}, {}, import("mongoose").Document<unknown, {}, ISandboxUsageSegment, {}, import("mongoose").DefaultSchemaOptions> & ISandboxUsageSegment & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ISandboxUsageSegment>;
+export default _default;

package/dist/sandbox-usage-segment.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const sandboxUsageSegmentSchema = new mongoose_1.Schema({
+    sandbox_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Sandbox",
+        required: true,
+        index: true,
+    },
+    user_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+        index: true,
+    },
+    team_id: {
+        type: mongoose_1.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",
+});
+exports.default = (0, mongoose_1.model)("SandboxUsageSegment", sandboxUsageSegmentSchema, "sandbox_usage_segments");

package/dist/sandbox.d.ts

@@ -0,0 +1,9 @@
+import { ISandbox } from "./types/sandbox";
+declare const _default: import("mongoose").Model<ISandbox, {}, {}, {}, import("mongoose").Document<unknown, {}, ISandbox, {}, import("mongoose").DefaultSchemaOptions> & ISandbox & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ISandbox>;
+export default _default;

package/dist/sandbox.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const sandboxSchema = new mongoose_1.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    user_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    team: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+        default: null,
+    },
+    project_environment: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "ProjectEnvironment",
+        default: null,
+    },
+    template: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(enum_1.SANDBOX_STATUS),
+        required: true,
+        default: enum_1.SANDBOX_STATUS.STARTING,
+    },
+    nomad_job_id: {
+        type: String,
+        required: true,
+    },
+    nomad_alloc_id: {
+        type: String,
+        default: null,
+    },
+    region: {
+        type: mongoose_1.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(enum_1.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: mongoose_1.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 });
+exports.default = (0, mongoose_1.model)("Sandbox", sandboxSchema);

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+import { IServer } from "./types";
+declare const _default: import("mongoose").Model<IServer, {}, {}, {}, import("mongoose").Document<unknown, {}, IServer, {}, import("mongoose").DefaultSchemaOptions> & IServer & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IServer>;
+export default _default;

package/dist/server.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const serverSchema = new mongoose_1.Schema({
+    name: {
+        type: String,
+        required: true,
+    },
+    url: String,
+    grpc_address: String,
+    userId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    teamId: {
+        type: mongoose_1.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(enum_1.SERVER_STATUS),
+        default: enum_1.SERVER_STATUS.Active,
+    },
+    protocol: {
+        type: String,
+        enum: Object.values(enum_1.SERVER_PROTOCOL),
+        default: enum_1.SERVER_PROTOCOL.TCP,
+    },
+    default: Boolean,
+    is_custom_provision: {
+        type: Boolean,
+        default: true,
+    },
+    region: {
+        type: mongoose_1.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 });
+exports.default = (0, mongoose_1.model)("Server", serverSchema);

package/dist/settings.d.ts

@@ -0,0 +1,9 @@
+import { ISettings } from "./types";
+declare const _default: import("mongoose").Model<ISettings, {}, {}, {}, import("mongoose").Document<unknown, {}, ISettings, {}, import("mongoose").DefaultSchemaOptions> & ISettings & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ISettings>;
+export default _default;

package/dist/settings.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const settingsSchema = new mongoose_1.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",
+});
+exports.default = (0, mongoose_1.model)("Settings", settingsSchema, "app_settings");

package/dist/storage.d.ts

@@ -0,0 +1,36 @@
+import { IStorageBucket, IStorageCredential, IStorageObject, IStorageToken, IStorageUpload } from "./types/storage";
+export declare const StorageBucket: import("mongoose").Model<IStorageBucket, {}, {}, {}, import("mongoose").Document<unknown, {}, IStorageBucket, {}, import("mongoose").DefaultSchemaOptions> & IStorageBucket & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IStorageBucket>;
+export declare const StorageObject: import("mongoose").Model<IStorageObject, {}, {}, {}, import("mongoose").Document<unknown, {}, IStorageObject, {}, import("mongoose").DefaultSchemaOptions> & IStorageObject & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IStorageObject>;
+export declare const StorageUpload: import("mongoose").Model<IStorageUpload, {}, {}, {}, import("mongoose").Document<unknown, {}, IStorageUpload, {}, import("mongoose").DefaultSchemaOptions> & IStorageUpload & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IStorageUpload>;
+export declare const StorageToken: import("mongoose").Model<IStorageToken, {}, {}, {}, import("mongoose").Document<unknown, {}, IStorageToken, {}, import("mongoose").DefaultSchemaOptions> & IStorageToken & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IStorageToken>;
+export declare const StorageCredential: import("mongoose").Model<IStorageCredential, {}, {}, {}, import("mongoose").Document<unknown, {}, IStorageCredential, {}, import("mongoose").DefaultSchemaOptions> & IStorageCredential & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IStorageCredential>;

package/dist/storage.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageCredential = exports.StorageToken = exports.StorageUpload = exports.StorageObject = exports.StorageBucket = void 0;
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const storageBucketSchema = new mongoose_1.Schema({
+    name: { type: String, required: true, trim: true },
+    project: { type: mongoose_1.Schema.Types.ObjectId, ref: "Project", required: false, index: true },
+    user_id: { type: mongoose_1.Schema.Types.ObjectId, ref: "User", required: false, index: true },
+    team: { type: mongoose_1.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(enum_1.StorageBucketStatus), default: enum_1.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 mongoose_1.Schema({
+    bucket: { type: mongoose_1.Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
+    project: { type: mongoose_1.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 mongoose_1.Schema({
+    bucket: { type: mongoose_1.Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
+    project: { type: mongoose_1.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(enum_1.StorageUploadStatus), default: enum_1.StorageUploadStatus.Pending, index: true },
+    expires_at: { type: Date, required: true, index: true },
+    completed_at: { type: Date },
+}, { timestamps: true });
+const storageTokenSchema = new mongoose_1.Schema({
+    name: { type: String, required: true, trim: true },
+    token_hash: { type: String, required: true, unique: true },
+    prefix: { type: String, required: true },
+    project: { type: mongoose_1.Schema.Types.ObjectId, ref: "Project", required: false, index: true },
+    buckets: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "StorageBucket" }],
+    user_id: { type: mongoose_1.Schema.Types.ObjectId, ref: "User", required: false, index: true },
+    team: { type: mongoose_1.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(enum_1.StorageTokenStatus), default: enum_1.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 mongoose_1.Schema({
+    name: { type: String, required: true, trim: true },
+    bucket: { type: mongoose_1.Schema.Types.ObjectId, ref: "StorageBucket", required: true, index: true },
+    project: { type: mongoose_1.Schema.Types.ObjectId, ref: "Project", required: false, index: true },
+    user_id: { type: mongoose_1.Schema.Types.ObjectId, ref: "User", required: false, index: true },
+    team: { type: mongoose_1.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(enum_1.StorageCredentialRole), required: true },
+    status: { type: String, enum: Object.values(enum_1.StorageCredentialStatus), default: enum_1.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" });
+exports.StorageBucket = (0, mongoose_1.model)("StorageBucket", storageBucketSchema);
+exports.StorageObject = (0, mongoose_1.model)("StorageObject", storageObjectSchema);
+exports.StorageUpload = (0, mongoose_1.model)("StorageUpload", storageUploadSchema);
+exports.StorageToken = (0, mongoose_1.model)("StorageToken", storageTokenSchema);
+exports.StorageCredential = (0, mongoose_1.model)("StorageCredential", storageCredentialSchema);

package/dist/subscription.d.ts

@@ -0,0 +1,9 @@
+import { ISubscription } from "./types";
+declare const _default: import("mongoose").Model<ISubscription, {}, {}, {}, import("mongoose").Document<unknown, {}, ISubscription, {}, import("mongoose").DefaultSchemaOptions> & ISubscription & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ISubscription>;
+export default _default;

package/dist/subscription.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const subscriptionSchema = new mongoose_1.Schema({
+    initial_start_date: {
+        type: String,
+        required: true,
+    },
+    due_amount: {
+        type: Number,
+        default: 0
+    },
+    team_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+    },
+    admin_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        required: true,
+        ref: "User",
+    },
+    billable_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        required: true,
+        ref: "User",
+    },
+    project_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        required: false,
+        ref: "Project",
+        default: null,
+    },
+    plan_type: {
+        type: String,
+        enum: Object.values(enum_1.SUBSCRIPTION_PLAN_TYPE),
+        default: enum_1.SUBSCRIPTION_PLAN_TYPE.FreePlan,
+    },
+    status: {
+        type: String,
+        enum: Object.values(enum_1.SUBSCRIPTION_STATUS),
+        default: enum_1.SUBSCRIPTION_STATUS.ACTIVE,
+    },
+    grafana_org_id: String,
+    specifications: {
+        type: Object,
+        default: {},
+        select: true,
+    },
+    amount: Number,
+    debit_date: String,
+    start_date: String,
+    expiry_date: String,
+    reminder_date: String,
+    transaction_retries: Number,
+    downgraded: {
+        default: false,
+        type: Boolean
+    },
+    is_pending_downgrade: {
+        type: Boolean,
+        default: false,
+    },
+    disabled_at: {
+        required: false,
+        type: Date,
+    },
+    trigger_created: {
+        type: Boolean,
+        default: false,
+    },
+    trigger_created_at: {
+        type: String,
+    },
+    job_identifier: {
+        type: String,
+    },
+}, {
+    timestamps: true,
+    collection: "subscriptions",
+});
+exports.default = (0, mongoose_1.model)("Subscription", subscriptionSchema);

package/dist/tag.d.ts

@@ -0,0 +1,9 @@
+import { ITag } from "./types";
+declare const _default: import("mongoose").Model<ITag, {}, {}, {}, import("mongoose").Document<unknown, {}, ITag, {}, import("mongoose").DefaultSchemaOptions> & ITag & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ITag>;
+export default _default;

package/dist/tag.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const tagSchema = new mongoose_1.Schema({
+    name: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    color: {
+        type: String,
+        required: true,
+    },
+    teamId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+        default: null,
+    },
+    createdBy: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+}, {
+    timestamps: true,
+    collection: "tags",
+});
+tagSchema.index({ teamId: 1, name: 1 }, { unique: true });
+exports.default = (0, mongoose_1.model)("Tag", tagSchema);