@resolveio/server-lib 3.2.11 → 3.2.12

package/collections/active-subscription.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { ActiveSubscriptionModel } from '../models/active-subscription.model';
+interface ResolveIOModel extends ActiveSubscriptionModel, Document {
+}
+export declare const ActiveSubscriptions: Model<ResolveIOModel>;
+export declare const ActiveSubscriptionVersions: Model<ResolveIOModel>;
+export {};

package/collections/active-subscription.collection.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    date: {
+        type: Date
+    },
+    publication: {
+        type: String
+    },
+    subData: {
+        type: String
+    },
+    collections: {
+        type: Array
+    },
+    'collections.$': {
+        type: String
+    },
+    clients: {
+        type: Array
+    },
+    'clients.$': {
+        type: Object
+    },
+    'clients.$.id_user': {
+        type: String
+    },
+    'clients.$.messageId': {
+        type: Number
+    },
+    'clients.$.id_socket': {
+        type: String
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.ActiveSubscriptions = index_1.ResolveIOServer.getMainDB().model('active-subscriptions', DefaultSchema);
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.ActiveSubscriptions['versionCollection'] = 'active-subscriptions.versions';
+exports.ActiveSubscriptionVersions = index_1.ResolveIOServer.getMainDB().model(exports.ActiveSubscriptions['versionCollection'], VersionSchema);

package/collections/app-status.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { AppStatusModel } from '../models/app-status.model';
+interface ResolveIOModel extends AppStatusModel, Document {
+}
+export declare const AppStatus: Model<ResolveIOModel>;
+export declare const AppStatusVersions: Model<ResolveIOModel>;
+export {};

package/collections/app-status.collection.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    message: {
+        type: String
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.AppStatus = index_1.ResolveIOServer.getMainDB().model('app-statuses', DefaultSchema);
+exports.AppStatus['simplschema'] = new simpl_schema_1.default(schema);
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.AppStatus['versionCollection'] = 'app-statuses.versions';
+exports.AppStatusVersions = index_1.ResolveIOServer.getMainDB().model(exports.AppStatus['versionCollection'], VersionSchema);

package/collections/app-version.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { AppVersionModel } from '../models/app-version.model';
+interface ResolveIOModel extends AppVersionModel, Document {
+}
+export declare const AppVersions: Model<ResolveIOModel>;
+export declare const AppVersionVersions: Model<ResolveIOModel>;
+export {};

package/collections/app-version.collection.js

@@ -0,0 +1,56 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    version: {
+        type: Number
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.AppVersions = index_1.ResolveIOServer.getMainDB().model('app-versions', DefaultSchema);
+var checkSchema = __assign({}, schema);
+checkSchema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(checkSchema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.AppVersions['versionCollection'] = 'app-versions.versions';
+exports.AppVersionVersions = index_1.ResolveIOServer.getMainDB().model(exports.AppVersions['versionCollection'], VersionSchema);
+schema.version.type = simpl_schema_1.default.Integer;
+exports.AppVersions['simplschema'] = new simpl_schema_1.default(schema);

package/collections/billing-logged-in-users.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { BillingLoggedInUserModel } from '../models/billing-logged-in-users.model';
+interface ResolveIOModel extends BillingLoggedInUserModel, Document {
+}
+export declare let BillingLoggedInUsers: Model<ResolveIOModel>;
+export declare let BillingLoggedInUserVersions: Model<ResolveIOModel>;
+export {};

package/collections/billing-logged-in-users.collection.js

@@ -0,0 +1,73 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var index_1 = require("../index");
+var simpl_schema_1 = require("simpl-schema");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    date: {
+        type: Date
+    },
+    id_user: {
+        type: String
+    },
+    user: {
+        type: String
+    },
+    client: {
+        type: String
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+DefaultSchema.index({ client: 1, id_user: 1, date: 1 });
+exports.BillingLoggedInUsers = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.BillingLoggedInUsers = index_1.ResolveIOServer.getSupportDB().model('billing-logged-in-users', DefaultSchema);
+    exports.BillingLoggedInUsers['simplschema'] = new simpl_schema_1.default(schema);
+}
+var vSchema = __assign({}, schema);
+vSchema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(vSchema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.BillingLoggedInUsers['versionCollection'] = 'billing-logged-in-users.versions';
+}
+exports.BillingLoggedInUserVersions = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    index_1.ResolveIOServer.getMainDB().model(exports.BillingLoggedInUsers['versionCollection'], VersionSchema);
+}

package/collections/counter.collection.d.ts

@@ -0,0 +1,9 @@
+import { Model, Document } from 'mongoose';
+import { CounterModel } from '../models/counter.model';
+interface ResolveIOModel extends CounterModel, Document {
+}
+export declare const Counters: Model<ResolveIOModel>;
+export declare let SupportCounters: Model<ResolveIOModel>;
+export declare const CounterVersions: Model<ResolveIOModel>;
+export declare let SupportCounterVersions: Model<ResolveIOModel>;
+export {};

package/collections/counter.collection.js

@@ -0,0 +1,73 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    type: {
+        type: String
+    },
+    count: {
+        type: Number
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Counters = index_1.ResolveIOServer.getMainDB().model('counters', DefaultSchema);
+exports.SupportCounters = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportCounters = index_1.ResolveIOServer.getSupportDB().model('counters', DefaultSchema);
+}
+var checkSchema = __assign({}, schema);
+checkSchema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(checkSchema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Counters['versionCollection'] = 'counters.versions';
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportCounters['versionCollection'] = 'counters.versions';
+}
+exports.CounterVersions = index_1.ResolveIOServer.getMainDB().model(exports.Counters['versionCollection'], VersionSchema);
+exports.SupportCounterVersions = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportCounterVersions = index_1.ResolveIOServer.getSupportDB().model(exports.SupportCounters['versionCollection'], VersionSchema);
+}
+schema.count.type = simpl_schema_1.default.Integer;
+exports.Counters['simplschema'] = new simpl_schema_1.default(schema);
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportCounters['simplschema'] = new simpl_schema_1.default(schema);
+}

package/collections/cron-job-history.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { CronJobModel } from '../models/cron-job.model';
+interface ResolveIOModel extends CronJobModel, Document {
+}
+export declare const CronJobHistory: Model<ResolveIOModel>;
+export declare const CronJobHistoryVersions: Model<ResolveIOModel>;
+export {};

package/collections/cron-job-history.collection.js

@@ -0,0 +1,86 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    name: {
+        type: String
+    },
+    reoccuring: {
+        type: Boolean
+    },
+    time_to_run: {
+        type: String
+    },
+    method_name: {
+        type: String
+    },
+    last_run: {
+        type: Date
+    },
+    next_run: {
+        type: Date
+    },
+    id_cronjob: {
+        type: String
+    },
+    passed: {
+        type: Boolean
+    },
+    error: {
+        type: String
+    },
+    start_time: {
+        type: Date
+    },
+    end_time: {
+        type: Date
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+DefaultSchema.index({ createdAt: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 7 });
+exports.CronJobHistory = index_1.ResolveIOServer.getMainDB().model('cron-job-histories', DefaultSchema);
+var vSchema = __assign({}, schema);
+vSchema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(vSchema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.CronJobHistory['versionCollection'] = 'cron-job-histories.versions';
+exports.CronJobHistoryVersions = index_1.ResolveIOServer.getMainDB().model(exports.CronJobHistory['versionCollection'], VersionSchema);
+exports.CronJobHistory['simplschema'] = new simpl_schema_1.default(schema);

package/collections/cron-job.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { CronJobModel } from '../models/cron-job.model';
+interface ResolveIOModel extends CronJobModel, Document {
+}
+export declare const CronJobs: Model<ResolveIOModel>;
+export declare const CronJobVersions: Model<ResolveIOModel>;
+export {};

package/collections/cron-job.collection.js

@@ -0,0 +1,89 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    name: {
+        type: String
+    },
+    repeat: {
+        type: Boolean
+    },
+    time_to_run: {
+        type: String
+    },
+    method_run: {
+        type: String
+    },
+    method_run_data: {
+        type: Object,
+        blackbox: true,
+        optional: true
+    },
+    method_complete: {
+        type: String,
+        optional: true
+    },
+    method_complete_data: {
+        type: Object,
+        blackbox: true,
+        optional: true
+    },
+    running: {
+        type: Boolean
+    },
+    timezone: {
+        type: String,
+        optional: true
+    },
+    next_run: {
+        type: Date,
+        optional: true
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.CronJobs = index_1.ResolveIOServer.getMainDB().model('cron-jobs', DefaultSchema);
+var vSchema = __assign({}, schema);
+vSchema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(vSchema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.CronJobs['versionCollection'] = 'cron-jobs.versions';
+exports.CronJobVersions = index_1.ResolveIOServer.getMainDB().model(exports.CronJobs['versionCollection'], VersionSchema);
+exports.CronJobs['simplschema'] = new simpl_schema_1.default(schema);

package/collections/file.collection.d.ts

@@ -0,0 +1,9 @@
+import { Model, Document } from 'mongoose';
+import { FileModel } from '../models/file.model';
+interface ResolveIOModel extends FileModel, Document {
+}
+export declare const Files: Model<ResolveIOModel>;
+export declare let SupportFiles: Model<ResolveIOModel>;
+export declare const FileVersions: Model<ResolveIOModel>;
+export declare let SupportFileVersions: Model<ResolveIOModel>;
+export {};

package/collections/file.collection.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    name: {
+        type: String
+    },
+    size: {
+        type: Number
+    },
+    key: {
+        type: String
+    },
+    type: {
+        type: String
+    },
+    order: {
+        type: Number
+    },
+    status: {
+        type: String,
+        optional: true
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Files = index_1.ResolveIOServer.getMainDB().model('files', DefaultSchema);
+exports.SupportFiles = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportFiles = index_1.ResolveIOServer.getSupportDB().model('files', DefaultSchema);
+}
+exports.Files['simplschema'] = new simpl_schema_1.default(schema);
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportFiles['simplschema'] = new simpl_schema_1.default(schema);
+}
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Files['versionCollection'] = 'files.versions';
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportFiles['versionCollection'] = 'files.versions';
+}
+exports.FileVersions = index_1.ResolveIOServer.getMainDB().model(exports.Files['versionCollection'], VersionSchema);
+exports.SupportFileVersions = null;
+if (index_1.ResolveIOServer.getSupportDB()) {
+    exports.SupportFileVersions = index_1.ResolveIOServer.getSupportDB().model(exports.Files['versionCollection'], VersionSchema);
+}

package/collections/flag.collection.d.ts

@@ -0,0 +1,7 @@
+import { Model, Document } from 'mongoose';
+import { FlagModel } from '../models/flag.model';
+interface ResolveIOModel extends FlagModel, Document {
+}
+export declare const Flags: Model<ResolveIOModel>;
+export declare const FlagVersions: Model<ResolveIOModel>;
+export {};

package/collections/flag.collection.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var mongoose_1 = require("mongoose");
+var simpl_schema_1 = require("simpl-schema");
+var index_1 = require("../index");
+var schema = {
+    _id: {
+        type: String,
+        optional: true
+    },
+    __v: {
+        type: Number,
+        optional: true
+    },
+    updatedAt: {
+        type: Date,
+        optional: true
+    },
+    createdAt: {
+        type: Date,
+        optional: true
+    },
+    type: {
+        type: String
+    },
+    value: {
+        type: Boolean,
+        optional: true
+    }
+};
+var DefaultSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Flags = index_1.ResolveIOServer.getMainDB().model('flags', DefaultSchema);
+exports.Flags['simplschema'] = new simpl_schema_1.default(schema);
+schema._id = {
+    type: mongoose_1.Schema.Types.Mixed
+};
+var VersionSchema = new mongoose_1.Schema(schema, {
+    skipVersioning: true,
+    versionKey: false,
+    timestamps: true
+});
+exports.Flags['versionCollection'] = 'flags.versions';
+exports.FlagVersions = index_1.ResolveIOServer.getMainDB().model(exports.Flags['versionCollection'], VersionSchema);