@terreno/api 0.0.1

package/dist/plugins.js

@@ -0,0 +1,315 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateOnly = void 0;
+exports.baseUserPlugin = baseUserPlugin;
+exports.isDeletedPlugin = isDeletedPlugin;
+exports.isDisabledPlugin = isDisabledPlugin;
+exports.createdUpdatedPlugin = createdUpdatedPlugin;
+exports.firebaseJWTPlugin = firebaseJWTPlugin;
+exports.findOneOrNone = findOneOrNone;
+exports.findExactlyOne = findExactlyOne;
+exports.upsertPlugin = upsertPlugin;
+var luxon_1 = require("luxon");
+var mongoose_1 = __importStar(require("mongoose"));
+var errors_1 = require("./errors");
+function baseUserPlugin(schema) {
+    schema.add({ admin: { default: false, type: Boolean } });
+    schema.add({ email: { index: true, type: String } });
+}
+function isDeletedPlugin(schema, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = false; }
+    schema.add({
+        deleted: {
+            default: defaultValue,
+            description: "Deleted objects are not returned in any find() or findOne() by default. " +
+                "Add {deleted: true} to find them.",
+            index: true,
+            type: Boolean,
+        },
+    });
+    function applyDeleteFilter(q) {
+        var query = q.getQuery();
+        if (query && query.deleted === undefined) {
+            void q.where({ deleted: { $ne: true } });
+        }
+    }
+    schema.pre("find", function () {
+        applyDeleteFilter(this);
+    });
+    schema.pre("findOne", function () {
+        applyDeleteFilter(this);
+    });
+}
+function isDisabledPlugin(schema, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = false; }
+    schema.add({
+        disabled: {
+            default: defaultValue,
+            description: "When a user is set to disable, all requests will return a 401",
+            index: true,
+            type: Boolean,
+        },
+    });
+}
+function createdUpdatedPlugin(schema) {
+    schema.add({ updated: { index: true, type: Date } });
+    schema.add({ created: { index: true, type: Date } });
+    schema.pre("save", function () {
+        if (this.disableCreatedUpdatedPlugin === true) {
+            return;
+        }
+        // If we aren't specifying created, use now.
+        if (!this.created) {
+            this.created = new Date();
+        }
+        // All writes change the updated time.
+        this.updated = new Date();
+    });
+    schema.pre(/save|updateOne|insertMany/, function () {
+        void this.updateOne({}, { $set: { updated: new Date() } });
+    });
+}
+function firebaseJWTPlugin(schema) {
+    schema.add({ firebaseId: { index: true, type: String } });
+}
+/**
+ * This adds a static method `Model.findOneOrNone` to the schema. This should replace `Model.findOne` in most instances.
+ * `Model.findOne` should only be used with a unique index, but that's not apparent from the docs. Otherwise you can wind
+ * up with a random document that matches the query. The returns either null if no document matches, the actual
+ * document, or throws an exception if multiple are found.
+ * @param schema Mongoose Schema
+ */
+function findOneOrNone(schema) {
+    schema.statics.findOneOrNone = function (query, errorArgs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.find(query)];
+                    case 1:
+                        results = _a.sent();
+                        if (results.length === 0) {
+                            return [2 /*return*/, null];
+                        }
+                        if (results.length > 1) {
+                            throw new errors_1.APIError(__assign({ detail: "query: ".concat(JSON.stringify(query)), status: 500, title: "".concat(this.modelName, ".findOne query returned multiple documents") }, errorArgs));
+                        }
+                        return [2 /*return*/, results[0]];
+                }
+            });
+        });
+    };
+}
+/**
+ * This adds a static method `Model.findExactlyOne` to the schema. This or findOneOrNone should replace `Model.findOne`
+ * in most instances.
+ * `Model.findOne` should only be used with a unique index, but that's not apparent from the docs. Otherwise you can wind
+ * up with a random document that matches the query. The returns the one matching document, or throws an exception if
+ * multiple or none are found.
+ * @param schema Mongoose Schema
+ */
+function findExactlyOne(schema) {
+    schema.statics.findExactlyOne = function (query, errorArgs) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.find(query)];
+                    case 1:
+                        results = _a.sent();
+                        if (results.length === 0) {
+                            throw new errors_1.APIError(__assign({ detail: "query: ".concat(JSON.stringify(query)), status: 404, title: "".concat(this.modelName, ".findExactlyOne query returned no documents") }, errorArgs));
+                        }
+                        if (results.length > 1) {
+                            throw new errors_1.APIError(__assign({ detail: "query: ".concat(JSON.stringify(query)), status: 500, title: "".concat(this.modelName, ".findExactlyOne query returned multiple documents") }, errorArgs));
+                        }
+                        return [2 /*return*/, results[0]];
+                }
+            });
+        });
+    };
+}
+/**
+ * This adds a static method `Model.upsert` to the schema. This method will either update an existing document
+ * that matches the conditions or create a new document if none exists. It throws an error if multiple documents
+ * match the conditions to prevent ambiguous updates.
+ * @param schema Mongoose Schema
+ */
+function upsertPlugin(schema) {
+    schema.statics.upsert = function (conditions, update) {
+        return __awaiter(this, void 0, void 0, function () {
+            var docs, doc, combinedData, newDoc;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.find(conditions)];
+                    case 1:
+                        docs = _a.sent();
+                        if (docs.length > 1) {
+                            throw new errors_1.APIError({
+                                detail: "query: ".concat(JSON.stringify(conditions)),
+                                status: 500,
+                                title: "".concat(this.modelName, ".upsert find query returned multiple documents"),
+                            });
+                        }
+                        doc = docs[0];
+                        if (doc) {
+                            // If the document exists, update it with the provided update values.
+                            Object.assign(doc, update);
+                            return [2 /*return*/, doc.save()];
+                        }
+                        combinedData = __assign(__assign({}, conditions), update);
+                        newDoc = new this(combinedData);
+                        return [2 /*return*/, newDoc.save()];
+                }
+            });
+        });
+    };
+}
+var DateOnly = /** @class */ (function (_super) {
+    __extends(DateOnly, _super);
+    function DateOnly(key, options) {
+        var _this = _super.call(this, key, options, "DateOnly") || this;
+        _this.$conditionalHandlers = __assign(__assign({}, mongoose_1.SchemaType.prototype.$conditionalHandlers), { $gt: _this.handleSingle, $gte: _this.handleSingle, $lt: _this.handleSingle, $lte: _this.handleSingle });
+        return _this;
+    }
+    DateOnly.prototype.handleSingle = function (val) {
+        return this.cast(val);
+    };
+    // Based on castForQuery in mongoose/lib/schema/date.js
+    // When using $gt, $gte, $lt, $lte, etc, we need to cast the value to a Date
+    DateOnly.prototype.castForQuery = function ($conditional, val, context) {
+        if ($conditional == null) {
+            return this.applySetters(val, context);
+        }
+        var handler = this.$conditionalHandlers[$conditional];
+        if (!handler) {
+            throw new Error("Can't use ".concat($conditional, " with DateOnly."));
+        }
+        return handler.call(this, val);
+    };
+    // When either setting a value to a DateOnly or fetching from the DB,
+    // we want to strip off the time portion.
+    DateOnly.prototype.cast = function (val) {
+        if (val instanceof Date) {
+            var date = luxon_1.DateTime.fromJSDate(val).toUTC().startOf("day");
+            if (!date.isValid) {
+                throw new mongoose_1.Error.CastError("DateOnly", val, this.path, new Error("Value is not a valid date"));
+            }
+            return date.toJSDate();
+        }
+        if (typeof val === "string" || typeof val === "number") {
+            var date = luxon_1.DateTime.fromJSDate(new Date(val)).toUTC().startOf("day");
+            if (!date.isValid) {
+                throw new mongoose_1.Error.CastError("DateOnly", val, this.path, new Error("Value is not a valid date"));
+            }
+            return date.toJSDate();
+        }
+        // Handle $gte, $lte, etc
+        if (typeof val === "object") {
+            return val;
+        }
+        throw new mongoose_1.Error.CastError("DateOnly", val, this.path, new Error("Value is not a valid date"));
+    };
+    DateOnly.prototype.get = function (val) {
+        return (val instanceof Date ? luxon_1.DateTime.fromJSDate(val).startOf("day").toJSDate() : val);
+    };
+    return DateOnly;
+}(mongoose_1.SchemaType));
+exports.DateOnly = DateOnly;
+// Register DateOnly with Mongoose's Schema.Types
+mongoose_1.default.Schema.Types.DateOnly = DateOnly;

package/dist/plugins.test.d.ts

@@ -0,0 +1 @@
+export {};