@codenameryuu/adonis-lucid-soft-deletes 1.3.0 → 1.5.0

package/build/configure.js

@@ -0,0 +1,14 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export async function configure(command) {
+    const codemods = await command.createCodemods();
+    await codemods.updateRcFile((rcFile) => {
+        rcFile.addProvider('@codenameryuu/adonis-lucid-soft-deletes/provider');
+    });
+}

package/build/index.js

@@ -0,0 +1,10 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export { configure } from './configure.js';
+export { SoftDeletes } from './src/mixin.js';

package/build/providers/lucid_soft_deletes_provider.js

@@ -0,0 +1,19 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { extendModelQueryBuilder } from '../src/bindings/model_query_builder.js';
+export default class LucidSoftDeletesProvider {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async boot() {
+        const { ModelQueryBuilder } = await this.app.import('@adonisjs/lucid/orm');
+        extendModelQueryBuilder(ModelQueryBuilder);
+    }
+}

package/build/src/bindings/model_query_builder.js

@@ -0,0 +1,41 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { Exception } from '@adonisjs/core/exceptions';
+/**
+ * Raises exception when model not with soft delete
+ */
+function ensureModelWithSoftDeletes(model) {
+    if (!('ignoreDeleted' in model && 'ignoreDeletedPaginate' in model)) {
+        throw new Exception(`${model.name} model don't support Soft Deletes`, {
+            code: 'E_MODEL_SOFT_DELETE',
+            status: 500,
+        });
+    }
+}
+/**
+ * Define SoftDeletes binding to ModelQueryBuilder
+ */
+export function extendModelQueryBuilder(builder) {
+    builder.macro('restore', async function () {
+        ensureModelWithSoftDeletes(this.model);
+        const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName;
+        if (!deletedAtColumn)
+            return;
+        await this.update({ [deletedAtColumn]: null });
+    });
+    builder.macro('withTrashed', function () {
+        ensureModelWithSoftDeletes(this.model);
+        return this.model.disableIgnore(this);
+    });
+    builder.macro('onlyTrashed', function () {
+        ensureModelWithSoftDeletes(this.model);
+        const deletedAtColumn = this.model.$getColumn('deletedAt')?.columnName;
+        return this.model.disableIgnore(this).whereNotNull(`${this.model.table}.${deletedAtColumn}`);
+    });
+}

package/build/src/mixin.js

@@ -0,0 +1,129 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { DateTime } from 'luxon';
+import { Exception } from '@adonisjs/core/exceptions';
+import { column, beforeFind, beforeFetch, beforePaginate } from '@adonisjs/lucid/orm';
+export function SoftDeletes(superclass) {
+    class ModelWithSoftDeletes extends superclass {
+        static ignoreDeleted(query) {
+            if (query['ignoreDeleted'] === false) {
+                return;
+            }
+            const isGroupLimitQuery = query.clone().toQuery().includes('adonis_group_limit_counter');
+            const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName;
+            const queryIgnoreDeleted = isGroupLimitQuery
+                ? query.knexQuery['_single'].table
+                : query;
+            queryIgnoreDeleted.whereNull(`${query.model.table}.${deletedAtColumn}`);
+        }
+        static ignoreDeletedPaginate([countQuery, query]) {
+            countQuery['ignoreDeleted'] = query['ignoreDeleted'];
+            this.ignoreDeleted(countQuery);
+        }
+        static disableIgnore(query) {
+            if (query['ignoreDeleted'] === false) {
+                return query;
+            }
+            query['ignoreDeleted'] = false;
+            return query;
+        }
+        /**
+         * Fetch all models without filter by deleted_at
+         */
+        static withTrashed() {
+            const query = this.query();
+            return this.disableIgnore(query);
+        }
+        /**
+         * Fetch models only with deleted_at
+         */
+        static onlyTrashed() {
+            const query = this.query();
+            const deletedAtColumn = query.model.$getColumn('deletedAt')?.columnName;
+            return this.disableIgnore(query).whereNotNull(`${query.model.table}.${deletedAtColumn}`);
+        }
+        /**
+         * Force delete instance property
+         */
+        $forceDelete = false;
+        /**
+         * Computed trashed property
+         */
+        get trashed() {
+            return this.deletedAt !== null;
+        }
+        /**
+         * Override default $getQueryFor method
+         */
+        $getQueryFor(action, client) {
+            /**
+             * Soft Delete
+             */
+            const softDelete = async () => {
+                this.deletedAt = DateTime.local();
+                await this.save();
+            };
+            if (action === 'delete' && !this.$forceDelete) {
+                return { del: softDelete, delete: softDelete };
+            }
+            if (action === 'insert') {
+                return super.$getQueryFor(action, client);
+            }
+            return super.$getQueryFor(action, client);
+        }
+        /**
+         * Override default delete method
+         */
+        async delete() {
+            await super.delete();
+            this.$isDeleted = this.$forceDelete;
+        }
+        /**
+         * Restore model
+         */
+        async restore() {
+            if (this.$isDeleted) {
+                throw new Exception('Cannot restore a model instance is was force deleted', {
+                    code: 'E_MODEL_FORCE_DELETED',
+                    status: 500,
+                });
+            }
+            if (!this.trashed) {
+                return this;
+            }
+            this.deletedAt = null;
+            await this.save();
+            return this;
+        }
+        /**
+         * Force delete model
+         */
+        async forceDelete() {
+            this.$forceDelete = true;
+            await this.delete();
+        }
+    }
+    __decorate([
+        column.dateTime()
+    ], ModelWithSoftDeletes.prototype, "deletedAt", void 0);
+    __decorate([
+        beforeFind(),
+        beforeFetch()
+    ], ModelWithSoftDeletes, "ignoreDeleted", null);
+    __decorate([
+        beforePaginate()
+    ], ModelWithSoftDeletes, "ignoreDeletedPaginate", null);
+    return ModelWithSoftDeletes;
+}

package/build/src/types/querybuilder.js

@@ -0,0 +1,9 @@
+/*
+ * adonis-lucid-soft-deletes
+ *
+ * (c) Lookin Anton <alsd@lookinlab.ru>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codenameryuu/adonis-lucid-soft-deletes",
   "description": "Addon for soft deletes Adonis JS 7 Lucid ORM",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "author": "codenameryuu",
   "license": "MIT",
   "homepage": "https://github.com/codenameryuu/adonis-lucid-soft-deletes#readme",
@@ -25,19 +25,15 @@
     "./provider": "./build/providers/lucid_soft_deletes_provider.js"
   },
   "scripts": {
-    "lint": "eslint .",
-    "format": "prettier --write .",
     "clean": "del-cli build",
-    "precompile": "npm run lint && npm run clean",
-    "compile": "tsc --emitDeclarationOnly --declaration",
-    "build": "npm run compile",
-    "pretest": "npm run lint",
-    "test": "c8 npm run quick:test",
     "typecheck": "tsc --noEmit",
+    "lint": "eslint . --ext=.ts",
+    "format": "prettier --write .",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run clean && tsc",
+    "release": "release-it",
     "version": "npm run build",
-    "prepublishOnly": "npm run build",
-    "release": "np",
-    "quick:test": "NODE_DEBUG=\"adonis-lucid-soft-deletes\" node --enable-source-maps --loader=ts-node/esm bin/test.ts"
+    "prepublishOnly": "npm run build"
   },
   "devDependencies": {
     "@adonisjs/assembler": "^7.7.0",