@brimble/models 3.8.45 → 3.8.47

package/dist/license.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const licenseSchema = new mongoose_1.Schema({
+    licenseKey: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    infisicalIdentity: String,
+    userId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    teamId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+        required: false,
+    },
+    subscriptionId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Subscription",
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(enum_1.LicenseStatus),
+        default: enum_1.LicenseStatus.ACTIVE,
+    },
+    tag: String,
+    devices: [
+        {
+            deviceId: {
+                type: String,
+                required: true,
+            },
+            hostname: String,
+            lastSeen: {
+                type: Date,
+                default: Date.now,
+            },
+            isActive: {
+                type: Boolean,
+                default: true,
+            },
+        },
+    ],
+    maxDevices: {
+        type: Number,
+        required: true,
+        default: 1,
+    },
+}, { timestamps: true });
+// licenseSchema.index({ userId: 1, status: 1 });
+// licenseSchema.index({ licenseKey: 1 });
+licenseSchema.methods.cleanupInactiveDevices = function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+        this.devices = this.devices.filter((device) => device.lastSeen > thirtyDaysAgo || device.isActive);
+        yield this.save();
+    });
+};
+exports.default = (0, mongoose_1.model)("License", licenseSchema, "licenses");

package/dist/load-balancer-port.d.ts

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

package/dist/load-balancer-port.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const loadBalancerPortSchema = new mongoose_1.Schema({
+    port: {
+        type: Number,
+        required: true,
+        min: 1,
+        max: 65535,
+    },
+    server_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Server",
+        required: true,
+    },
+    project_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Project",
+        required: true,
+    },
+    region_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Region",
+        required: true,
+    },
+}, { timestamps: true });
+exports.default = (0, mongoose_1.model)("LoadBalancerPort", loadBalancerPortSchema, "load_balancer_ports");

package/dist/logs.d.ts

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

package/dist/logs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const LogSchema = new mongoose_1.Schema({
+    name: String,
+    key: String,
+    commit: Object,
+    status: {
+        type: String,
+        enum: Object.values(enum_1.PROJECT_STATUS),
+        default: enum_1.PROJECT_STATUS.PENDING,
+    },
+    project: {
+        ref: "Project",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+    user: {
+        ref: "User",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+    team: {
+        ref: "Team",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+    preview: {
+        ref: "Preview",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+    environment: {
+        type: String,
+        enum: Object.values(enum_1.ENVIRONMENT),
+        default: enum_1.ENVIRONMENT.PRODUCTION,
+    },
+    jobs: Array,
+    startTime: mongoose_1.Schema.Types.Date,
+    endTime: mongoose_1.Schema.Types.Date,
+    deleted: mongoose_1.Schema.Types.Boolean,
+}, { timestamps: true });
+exports.default = (0, mongoose_1.model)("Log", LogSchema);

package/dist/member-permission.d.ts

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

package/dist/member-permission.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const memberPermissionSchema = new mongoose_1.Schema({
+    permission: { type: mongoose_1.Schema.Types.ObjectId, ref: "Permission" },
+    member: { type: mongoose_1.Schema.Types.ObjectId, ref: "Member" },
+    enabled: { type: Boolean, default: false },
+});
+exports.default = (0, mongoose_1.model)("MemberPermission", memberPermissionSchema);

package/dist/member.d.ts

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

package/dist/member.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const memberSchema = new mongoose_1.Schema({
+    user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+    },
+    email: String,
+    team: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+    },
+    role: {
+        type: String,
+        enum: Object.values(enum_1.ROLES),
+        default: enum_1.ROLES.MEMBER,
+    },
+    accepted: {
+        type: Boolean,
+        default: false,
+    },
+    invitedBy: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+    },
+    featureOnboarded: {
+        type: Boolean,
+        default: false,
+    },
+    permissions: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "MemberPermission" }],
+    project_environments: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "ProjectEnvironment" }],
+}, {
+    timestamps: {
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+    },
+});
+exports.default = (0, mongoose_1.model)("Member", memberSchema);

package/dist/object-storage-usage-segment.d.ts

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

package/dist/object-storage-usage-segment.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const objectStorageUsageSegmentSchema = new mongoose_1.Schema({
+    bucket_id: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "StorageBucket",
+        required: 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",
+        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",
+});
+exports.default = (0, mongoose_1.model)("ObjectStorageUsageSegment", objectStorageUsageSegmentSchema, "object_storage_usage_segments");

package/dist/ownership-transfer.d.ts

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

package/dist/ownership-transfer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const ownershipTransferSchema = new mongoose_1.Schema({
+    team: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Team",
+        required: true,
+    },
+    from_user: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "User",
+        required: true,
+    },
+    to_user: {
+        type: mongoose_1.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",
+    },
+});
+exports.default = (0, mongoose_1.model)("OwnershipTransfer", ownershipTransferSchema);

package/dist/permission.d.ts

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

package/dist/permission.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const permissionSchema = new mongoose_1.Schema({
+    title: { type: String },
+    role: [{ type: mongoose_1.Schema.Types.ObjectId, ref: "Role" }],
+    request: { type: Object },
+    type: { type: String, enum: Object.values(enum_1.PERMISSION_TYPE) },
+    enabled: { type: Boolean, default: false, select: true },
+});
+exports.default = (0, mongoose_1.model)("Permission", permissionSchema);

package/dist/plan_configuration.d.ts

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

package/{plan_configuration.ts → dist/plan_configuration.js}

@@ -1,9 +1,8 @@
-import mongoose, { Schema, Document, model } from "mongoose";
-import { SUBSCRIPTION_PLAN_TYPE } from "./enum";
-import { IPlanConfiguration } from "./types/plan_configuration";
-
-const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
-  {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const enum_1 = require("./enum");
+const PlanConfigurationSchema = new mongoose_1.Schema({
     tag: { type: String, required: true },
     slack_support: { type: Boolean, default: false },
     concurrent_builds: { type: Number, required: true },
@@ -18,7 +17,7 @@ const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
     price: { type: Number, required: true },
     password_enabled: { type: Boolean, required: false, default: true },
     autoscaling_enabled: { type: Boolean, default: false, required: false },
-    region: { type: Schema.Types.ObjectId, ref: "Region", required: false },
+    region: { type: mongoose_1.Schema.Types.ObjectId, ref: "Region", required: false },
     multi_region: { type: Boolean, default: false },
     unlimited_projects: { type: Boolean, default: false },
     ai_debug_enabled: { type: Boolean, default: false, required: false },
@@ -26,9 +25,9 @@ const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
     storage_bucket_enabled: { type: Boolean, default: false },
     storage_bucket_quota_gb: { type: Number, default: 5 },
     plan_type: {
-      type: String,
-      enum: Object.values(SUBSCRIPTION_PLAN_TYPE),
-      required: true,
+        type: String,
+        enum: Object.values(enum_1.SUBSCRIPTION_PLAN_TYPE),
+        required: true,
     },
     volumes_enabled: { type: Boolean, required: false, default: true },
     memory: { type: Number, required: true },
@@ -42,9 +41,9 @@ const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
     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: {} },
+    stripe_prices: { type: mongoose_1.Schema.Types.Mixed, required: false, default: {} },
     sandbox_max_count: { type: Number, required: false, default: 3 },
-    sanxbox_hours_max: { type: Number, required: false, default: 16},
+    sanxbox_hours_max: { type: Number, required: false, default: 16 },
     sandbox_enabled: { type: Boolean, required: false, default: true },
     sandbox_cpu_hours_included: { type: Number, default: 0 },
     sandbox_memory_gb_hours_included: { type: Number, default: 0 },
@@ -58,12 +57,5 @@ const PlanConfigurationSchema = new Schema<IPlanConfiguration>(
     sandbox_snapshot_gb_months_included: { type: Number, default: 0 },
     sandbox_max_volume_size_gb: { type: Number, default: 0 },
     sandbox_max_volumes: { type: Number, default: 0 }
-  },
-  { timestamps: true },
-);
-
-export default model<IPlanConfiguration>(
-  "PlanConfigurations",
-  PlanConfigurationSchema,
-  "plan_configurations",
-);
+}, { timestamps: true });
+exports.default = (0, mongoose_1.model)("PlanConfigurations", PlanConfigurationSchema, "plan_configurations");

package/dist/project/connection.d.ts

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

package/dist/project/connection.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = require("mongoose");
+const projectConnectionSchema = new mongoose_1.Schema({
+    service: {
+        ref: "Project",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+    project: {
+        ref: "Project",
+        type: mongoose_1.Schema.Types.ObjectId,
+    },
+}, { timestamps: true });
+exports.default = (0, mongoose_1.model)("ProjectConnection", projectConnectionSchema);

package/dist/project/index.d.ts

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