@aeriajs/security 0.0.162 → 0.0.163

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './define.js';
-export * from './middleware.js';
+export * from './middleware/index.js';
 export * from './middlewares/index.js';
 export * from './rateLimiting.js';
 export * from './use.js';

package/dist/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./define.js"), exports);
-__exportStar(require("./middleware.js"), exports);
+__exportStar(require("./middleware/index.js"), exports);
 __exportStar(require("./middlewares/index.js"), exports);
 __exportStar(require("./rateLimiting.js"), exports);
 __exportStar(require("./use.js"), exports);

package/dist/index.mjs

@@ -1,6 +1,6 @@
 "use strict";
 export * from "./define.mjs";
-export * from "./middleware.mjs";
+export * from "./middleware/index.mjs";
 export * from "./middlewares/index.mjs";
 export * from "./rateLimiting.mjs";
 export * from "./use.mjs";

package/dist/middleware/applyReadMiddlewares.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Collection, GetReturnType, GetAllReturnType, CountReturnType, CollectionReadPayload } from '@aeriajs/types';
+export declare const applyReadMiddlewares: <TContext extends Context>(payload: CollectionReadPayload, context: TContext & {
+    collection: Collection;
+}, fn: (p: typeof payload, context: Context) => Promise<GetReturnType<unknown> | GetAllReturnType<unknown> | CountReturnType>) => Promise<import("@aeriajs/types").Result.Either<any, any>>;

package/dist/middleware/applyReadMiddlewares.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyReadMiddlewares = void 0;
+const iterableMiddlewares_js_1 = require("./iterableMiddlewares.js");
+const applyReadMiddlewares = (payload, context, fn) => {
+    if (context.collection.middlewares) {
+        if (Array.isArray(context.collection.middlewares)) {
+            const readMiddlewares = context.collection.middlewares.map((middleware) => middleware.beforeRead).filter((fn) => !!fn);
+            const start = (0, iterableMiddlewares_js_1.iterableMiddlewares)(readMiddlewares, fn);
+            return start(payload, context);
+        }
+        if (context.collection.middlewares.beforeRead) {
+            return context.collection.middlewares.beforeRead(payload, context, fn);
+        }
+    }
+    return fn(payload, context);
+};
+exports.applyReadMiddlewares = applyReadMiddlewares;

package/dist/middleware/applyReadMiddlewares.mjs

@@ -0,0 +1,18 @@
+"use strict";
+import { iterableMiddlewares } from "./iterableMiddlewares.mjs";
+export const applyReadMiddlewares = (payload, context, fn) => {
+  if (context.collection.middlewares) {
+    if (Array.isArray(context.collection.middlewares)) {
+      const readMiddlewares = context.collection.middlewares.map((middleware) => middleware.beforeRead).filter((fn2) => !!fn2);
+      const start = iterableMiddlewares(
+        readMiddlewares,
+        fn
+      );
+      return start(payload, context);
+    }
+    if (context.collection.middlewares.beforeRead) {
+      return context.collection.middlewares.beforeRead(payload, context, fn);
+    }
+  }
+  return fn(payload, context);
+};

package/dist/middleware/applyWriteMiddlewares.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Collection, CollectionWritePayload, InsertReturnType } from '@aeriajs/types';
+export declare const applyWriteMiddlewares: <TDocument, TContext extends Context>(payload: CollectionWritePayload, context: TContext & {
+    collection: Collection;
+}, fn: (p: typeof payload, context: Context) => Promise<InsertReturnType<TDocument>>) => Promise<import("@aeriajs/types").Result.Either<any, any>>;

package/dist/middleware/applyWriteMiddlewares.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyWriteMiddlewares = void 0;
+const iterableMiddlewares_js_1 = require("./iterableMiddlewares.js");
+const applyWriteMiddlewares = (payload, context, fn) => {
+    if (context.collection.middlewares) {
+        if (Array.isArray(context.collection.middlewares)) {
+            const writeMiddlewares = context.collection.middlewares.map((middleware) => middleware.beforeWrite).filter((fn) => !!fn);
+            const start = (0, iterableMiddlewares_js_1.iterableMiddlewares)(writeMiddlewares, fn);
+            return start(payload, context);
+        }
+        if (context.collection.middlewares.beforeWrite) {
+            return context.collection.middlewares.beforeWrite(payload, context, fn);
+        }
+    }
+    return fn(payload, context);
+};
+exports.applyWriteMiddlewares = applyWriteMiddlewares;

package/dist/middleware/applyWriteMiddlewares.mjs

@@ -0,0 +1,18 @@
+"use strict";
+import { iterableMiddlewares } from "./iterableMiddlewares.mjs";
+export const applyWriteMiddlewares = (payload, context, fn) => {
+  if (context.collection.middlewares) {
+    if (Array.isArray(context.collection.middlewares)) {
+      const writeMiddlewares = context.collection.middlewares.map((middleware) => middleware.beforeWrite).filter((fn2) => !!fn2);
+      const start = iterableMiddlewares(
+        writeMiddlewares,
+        fn
+      );
+      return start(payload, context);
+    }
+    if (context.collection.middlewares.beforeWrite) {
+      return context.collection.middlewares.beforeWrite(payload, context, fn);
+    }
+  }
+  return fn(payload, context);
+};

package/dist/middleware/define.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionMiddleware } from '@aeriajs/types';
+export declare const defineCollectionMiddleware: <TCollectionMiddleware extends CollectionMiddleware<unknown>>(middleware: TCollectionMiddleware) => TCollectionMiddleware;

package/dist/middleware/define.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineCollectionMiddleware = void 0;
+const defineCollectionMiddleware = (middleware) => {
+    return middleware;
+};
+exports.defineCollectionMiddleware = defineCollectionMiddleware;

package/dist/middleware/define.mjs

@@ -0,0 +1,4 @@
+"use strict";
+export const defineCollectionMiddleware = (middleware) => {
+  return middleware;
+};

package/dist/middleware/index.d.ts

@@ -0,0 +1,4 @@
+export * from './define.js';
+export * from './iterableMiddlewares.js';
+export * from './applyReadMiddlewares.js';
+export * from './applyWriteMiddlewares.js';

package/dist/middleware/index.js

@@ -0,0 +1,20 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./define.js"), exports);
+__exportStar(require("./iterableMiddlewares.js"), exports);
+__exportStar(require("./applyReadMiddlewares.js"), exports);
+__exportStar(require("./applyWriteMiddlewares.js"), exports);

package/dist/middleware/index.mjs

@@ -0,0 +1,5 @@
+"use strict";
+export * from "./define.mjs";
+export * from "./iterableMiddlewares.mjs";
+export * from "./applyReadMiddlewares.mjs";
+export * from "./applyWriteMiddlewares.mjs";

package/dist/middleware/iterableMiddlewares.d.ts

@@ -0,0 +1,2 @@
+import type { Middleware, MiddlewareNext, GenericMiddlewareNext, Context } from '@aeriajs/types';
+export declare const iterableMiddlewares: <TPayload, TReturn, TReturnNext extends GenericMiddlewareNext<TPayload, TReturn> = MiddlewareNext>(middlewares: Middleware<TPayload, TReturn, TReturnNext>[], end?: (payload: TPayload, _context: Context) => any) => (payload: TPayload, context: Context) => TReturn;

package/dist/{middleware.js → middleware/iterableMiddlewares.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.iterableMiddlewares = void 0;
-const iterableMiddlewares = function (middlewares, end = (_, initial) => initial) {
+const iterableMiddlewares = function (middlewares, end = (payload, _context) => payload) {
     const [first, ...subsequent] = middlewares;
     const it = function* () {
         for (const middleware of subsequent.concat([end])) {
-            yield (payload, initial, context) => {
+            yield (payload, context) => {
                 const { value: next } = it.next();
-                return middleware(payload, initial, context, next);
+                return middleware(Object.assign({}, payload), context, next);
             };
         }
     }();
-    return (payload, initial, context) => {
+    return (payload, context) => {
         const { value: next } = it.next();
-        return first(payload, initial, context, next);
+        return first(Object.assign({}, payload), context, next);
     };
 };
 exports.iterableMiddlewares = iterableMiddlewares;

package/dist/{middleware.mjs → middleware/iterableMiddlewares.mjs}

@@ -1,16 +1,16 @@
 "use strict";
-export const iterableMiddlewares = function(middlewares, end = (_, initial) => initial) {
+export const iterableMiddlewares = function(middlewares, end = (payload, _context) => payload) {
   const [first, ...subsequent] = middlewares;
   const it = function* () {
     for (const middleware of subsequent.concat([end])) {
-      yield (payload, initial, context) => {
+      yield (payload, context) => {
         const { value: next } = it.next();
-        return middleware(payload, initial, context, next);
+        return middleware(Object.assign({}, payload), context, next);
       };
     }
   }();
-  return (payload, initial, context) => {
+  return (payload, context) => {
     const { value: next } = it.next();
-    return first(payload, initial, context, next);
+    return first(Object.assign({}, payload), context, next);
   };
 };

package/dist/middlewares/immutability.d.ts

@@ -1,12 +1,11 @@
-import type { Context, CollectionHookProps, GenericMiddlewareNext } from '@aeriajs/types';
-import type { CollectionHookReadPayload, CollectionHookWritePayload } from '../types.js';
+import type { Context, CollectionProps, GenericMiddlewareNext, CollectionReadPayload, CollectionWritePayload } from '@aeriajs/types';
 import { Result, ACError } from '@aeriajs/types';
-export declare const checkImmutabilityRead: <T extends CollectionHookReadPayload>(props: CollectionHookProps<T>, initial: Result.Either<unknown, T>, context: Context, next: GenericMiddlewareNext<Result.Result<T>, CollectionHookProps<T>>) => Promise<Result.Result<T> | {
+export declare const checkImmutabilityRead: <T extends CollectionReadPayload>(props: Result.Result<CollectionProps<T>>, context: Context, next: GenericMiddlewareNext<typeof props, typeof props>) => Promise<Result.Result<CollectionProps<T>> | {
     readonly _tag: "Error";
     readonly error: ACError.TargetImmutable | ACError.ResourceNotFound;
     readonly result: undefined;
 }>;
-export declare const checkImmutabilityWrite: <T extends CollectionHookWritePayload>(props: CollectionHookProps<T>, initial: Result.Either<unknown, T>, context: Context, next: GenericMiddlewareNext<Result.Result<T>, CollectionHookProps<T>>) => Promise<Result.Result<T> | {
+export declare const checkImmutabilityWrite: <T extends CollectionWritePayload>(props: Result.Result<CollectionProps<T>>, context: Context, next: GenericMiddlewareNext<typeof props, typeof props>) => Promise<Result.Result<CollectionProps<T>> | {
     readonly _tag: "Error";
     readonly error: ACError.TargetImmutable | ACError.ResourceNotFound;
     readonly result: undefined;

package/dist/middlewares/immutability.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkImmutabilityWrite = exports.checkImmutabilityRead = void 0;
+const mongodb_1 = require("mongodb");
 const types_1 = require("@aeriajs/types");
-const common_1 = require("@aeriajs/common");
 const checkImmutability = async (docId, props, context) => {
     if (!context.description.immutable) {
         return types_1.Result.result(props.payload);
@@ -10,7 +10,7 @@ const checkImmutability = async (docId, props, context) => {
     if (docId) {
         if (typeof context.description.immutable === 'function') {
             const doc = await context.collection.model.findOne({
-                _id: docId,
+                _id: new mongodb_1.ObjectId(docId),
             });
             if (!doc) {
                 return types_1.Result.error(types_1.ACError.ResourceNotFound);
@@ -24,21 +24,27 @@ const checkImmutability = async (docId, props, context) => {
     }
     return types_1.Result.result(props.payload);
 };
-const checkImmutabilityRead = async (props, initial, context, next) => {
-    const originalPayload = (0, common_1.throwIfError)(initial);
-    const { result: payload, error } = await checkImmutability(originalPayload.filters._id, props, context);
+const checkImmutabilityRead = async (props, context, next) => {
+    const { payload: originalPayload } = props.result;
+    const { result: payload, error } = await checkImmutability(originalPayload.filters._id, props.result, context);
     if (error) {
         return types_1.Result.error(error);
     }
-    return next(payload, types_1.Result.result(payload), context);
+    return next(types_1.Result.result({
+        ...props.result,
+        payload,
+    }), context);
 };
 exports.checkImmutabilityRead = checkImmutabilityRead;
-const checkImmutabilityWrite = async (props, initial, context, next) => {
-    const originalPayload = (0, common_1.throwIfError)(initial);
-    const { result: payload, error } = await checkImmutability(originalPayload.what._id, props, context);
+const checkImmutabilityWrite = async (props, context, next) => {
+    const { payload: originalPayload } = props.result;
+    const { result: payload, error } = await checkImmutability(originalPayload.what._id, props.result, context);
     if (error) {
         return types_1.Result.error(error);
     }
-    return next(payload, types_1.Result.result(payload), context);
+    return next(types_1.Result.result({
+        ...props.result,
+        payload,
+    }), context);
 };
 exports.checkImmutabilityWrite = checkImmutabilityWrite;

package/dist/middlewares/immutability.mjs

@@ -1,6 +1,6 @@
 "use strict";
+import { ObjectId } from "mongodb";
 import { Result, ACError } from "@aeriajs/types";
-import { throwIfError } from "@aeriajs/common";
 const checkImmutability = async (docId, props, context) => {
   if (!context.description.immutable) {
     return Result.result(props.payload);
@@ -8,7 +8,7 @@ const checkImmutability = async (docId, props, context) => {
   if (docId) {
     if (typeof context.description.immutable === "function") {
       const doc = await context.collection.model.findOne({
-        _id: docId
+        _id: new ObjectId(docId)
       });
       if (!doc) {
         return Result.error(ACError.ResourceNotFound);
@@ -20,19 +20,25 @@ const checkImmutability = async (docId, props, context) => {
   }
   return Result.result(props.payload);
 };
-export const checkImmutabilityRead = async (props, initial, context, next) => {
-  const originalPayload = throwIfError(initial);
-  const { result: payload, error } = await checkImmutability(originalPayload.filters._id, props, context);
+export const checkImmutabilityRead = async (props, context, next) => {
+  const { payload: originalPayload } = props.result;
+  const { result: payload, error } = await checkImmutability(originalPayload.filters._id, props.result, context);
   if (error) {
     return Result.error(error);
   }
-  return next(payload, Result.result(payload), context);
+  return next(Result.result({
+    ...props.result,
+    payload
+  }), context);
 };
-export const checkImmutabilityWrite = async (props, initial, context, next) => {
-  const originalPayload = throwIfError(initial);
-  const { result: payload, error } = await checkImmutability(originalPayload.what._id, props, context);
+export const checkImmutabilityWrite = async (props, context, next) => {
+  const { payload: originalPayload } = props.result;
+  const { result: payload, error } = await checkImmutability(originalPayload.what._id, props.result, context);
   if (error) {
     return Result.error(error);
   }
-  return next(payload, Result.result(payload), context);
+  return next(Result.result({
+    ...props.result,
+    payload
+  }), context);
 };

package/dist/middlewares/ownership.d.ts

@@ -1,8 +1,7 @@
-import type { GenericMiddlewareNext, Context, CollectionHookProps } from '@aeriajs/types';
-import type { CollectionHookReadPayload, CollectionHookWritePayload } from '../types.js';
+import type { GenericMiddlewareNext, Context, CollectionProps, CollectionReadPayload, CollectionWritePayload } from '@aeriajs/types';
 import { Result, ACError } from '@aeriajs/types';
-export declare const checkOwnershipRead: <T extends CollectionHookReadPayload>(props: CollectionHookProps<T>, initial: Result.Either<unknown, T>, context: Context, next: GenericMiddlewareNext<Result.Result<T>, CollectionHookProps<T>>) => Promise<Result.Result<T>>;
-export declare const checkOwnershipWrite: <T extends CollectionHookWritePayload>(props: CollectionHookProps<T>, initial: Result.Either<unknown, T>, context: Context, next: GenericMiddlewareNext<Result.Result<T>, CollectionHookProps<T>>) => Promise<Result.Result<T> | {
+export declare const checkOwnershipRead: <T extends CollectionReadPayload>(props: Result.Result<CollectionProps<T>>, context: Context, next: GenericMiddlewareNext<typeof props, typeof props>) => Promise<Result.Result<CollectionProps<T>>>;
+export declare const checkOwnershipWrite: <T extends CollectionWritePayload>(props: Result.Result<CollectionProps<T>>, context: Context, next: GenericMiddlewareNext<typeof props, typeof props>) => Promise<Result.Result<CollectionProps<T>> | {
     readonly _tag: "Error";
     readonly error: ACError.OwnershipError;
     readonly result: undefined;

package/dist/middlewares/ownership.js

@@ -2,33 +2,37 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkOwnershipWrite = exports.checkOwnershipRead = void 0;
 const types_1 = require("@aeriajs/types");
-const common_1 = require("@aeriajs/common");
-const checkOwnershipRead = async (props, initial, context, next) => {
+const checkOwnershipRead = async (props, context, next) => {
     const { token, description } = context;
-    const payload = (0, common_1.throwIfError)(initial);
-    if (token.authenticated && description.owned) {
+    const { payload } = props.result;
+    if (token.authenticated && description.owned && description.owned !== 'on-write') {
         if (!token.roles.includes('root')) {
             payload.filters.owner = token.sub;
         }
     }
-    return next(props, types_1.Result.result(payload), context);
+    return next(types_1.Result.result({
+        ...props.result,
+        payload,
+    }), context);
 };
 exports.checkOwnershipRead = checkOwnershipRead;
-const checkOwnershipWrite = async (props, initial, context, next) => {
+const checkOwnershipWrite = async (props, context, next) => {
     const { token, description } = context;
-    const { parentId } = props;
-    const payload = (0, common_1.throwIfError)(initial);
+    const { payload, parentId } = props.result;
     if (token.authenticated && description.owned) {
         if (!payload.what._id || description.owned === 'always') {
             payload.what.owner = token.sub;
         }
         else {
-            return next(props, types_1.Result.result(payload), context);
+            return next(props, context);
         }
     }
     if ((!payload.what.owner && !parentId) && context.description.owned) {
         return types_1.Result.error(types_1.ACError.OwnershipError);
     }
-    return next(props, types_1.Result.result(payload), context);
+    return next(types_1.Result.result({
+        ...props.result,
+        payload,
+    }), context);
 };
 exports.checkOwnershipWrite = checkOwnershipWrite;

package/dist/middlewares/ownership.mjs

@@ -1,29 +1,33 @@
 "use strict";
 import { Result, ACError } from "@aeriajs/types";
-import { throwIfError } from "@aeriajs/common";
-export const checkOwnershipRead = async (props, initial, context, next) => {
+export const checkOwnershipRead = async (props, context, next) => {
   const { token, description } = context;
-  const payload = throwIfError(initial);
-  if (token.authenticated && description.owned) {
+  const { payload } = props.result;
+  if (token.authenticated && description.owned && description.owned !== "on-write") {
     if (!token.roles.includes("root")) {
       payload.filters.owner = token.sub;
     }
   }
-  return next(props, Result.result(payload), context);
+  return next(Result.result({
+    ...props.result,
+    payload
+  }), context);
 };
-export const checkOwnershipWrite = async (props, initial, context, next) => {
+export const checkOwnershipWrite = async (props, context, next) => {
   const { token, description } = context;
-  const { parentId } = props;
-  const payload = throwIfError(initial);
+  const { payload, parentId } = props.result;
   if (token.authenticated && description.owned) {
     if (!payload.what._id || description.owned === "always") {
       payload.what.owner = token.sub;
     } else {
-      return next(props, Result.result(payload), context);
+      return next(props, context);
     }
   }
   if (!payload.what.owner && !parentId && context.description.owned) {
     return Result.error(ACError.OwnershipError);
   }
-  return next(props, Result.result(payload), context);
+  return next(Result.result({
+    ...props.result,
+    payload
+  }), context);
 };

package/dist/middlewares/pagination.d.ts

@@ -1,7 +1,6 @@
-import type { CollectionHookProps, GenericMiddlewareNext, Context } from '@aeriajs/types';
-import type { CollectionHookReadPayload } from '../types.js';
+import type { CollectionProps, GenericMiddlewareNext, Context, CollectionReadPayload } from '@aeriajs/types';
 import { Result, ACError } from '@aeriajs/types';
-export declare const checkPagination: <T extends CollectionHookReadPayload>(props: CollectionHookProps<T>, initial: Result.Either<unknown, T>, context: Context, next: GenericMiddlewareNext<Result.Result<T>, CollectionHookProps<T>>) => Promise<Result.Result<T> | {
+export declare const checkPagination: <T extends CollectionReadPayload>(props: Result.Result<CollectionProps<T>>, context: Context, next: GenericMiddlewareNext<typeof props, typeof props>) => Promise<Result.Result<CollectionProps<T>> | {
     readonly _tag: "Error";
     readonly error: ACError.InvalidLimit;
     readonly result: undefined;

package/dist/middlewares/pagination.js

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkPagination = void 0;
 const types_1 = require("@aeriajs/types");
-const common_1 = require("@aeriajs/common");
-const checkPagination = async (props, initial, context, next) => {
-    const payload = (0, common_1.throwIfError)(initial);
-    if (payload.limit) {
-        if (payload.limit <= 0 || payload.limit > 150) {
+const checkPagination = async (props, context, next) => {
+    const { payload } = props.result;
+    switch (typeof payload.limit) {
+        case 'undefined': break;
+        case 'number': {
+            if (payload.limit <= 0) {
+                return types_1.Result.error(types_1.ACError.InvalidLimit);
+            }
+            if (context.config.security.paginationLimit && payload.limit > context.config.security.paginationLimit) {
+                return types_1.Result.error(types_1.ACError.InvalidLimit);
+            }
+            break;
+        }
+        default: {
             return types_1.Result.error(types_1.ACError.InvalidLimit);
         }
     }
-    return next(props, types_1.Result.result(payload), context);
+    return next(props, context);
 };
 exports.checkPagination = checkPagination;

package/dist/middlewares/pagination.mjs

@@ -1,12 +1,22 @@
 "use strict";
 import { Result, ACError } from "@aeriajs/types";
-import { throwIfError } from "@aeriajs/common";
-export const checkPagination = async (props, initial, context, next) => {
-  const payload = throwIfError(initial);
-  if (payload.limit) {
-    if (payload.limit <= 0 || payload.limit > 150) {
+export const checkPagination = async (props, context, next) => {
+  const { payload } = props.result;
+  switch (typeof payload.limit) {
+    case "undefined":
+      break;
+    case "number": {
+      if (payload.limit <= 0) {
+        return Result.error(ACError.InvalidLimit);
+      }
+      if (context.config.security.paginationLimit && payload.limit > context.config.security.paginationLimit) {
+        return Result.error(ACError.InvalidLimit);
+      }
+      break;
+    }
+    default: {
       return Result.error(ACError.InvalidLimit);
     }
   }
-  return next(props, Result.result(payload), context);
+  return next(props, context);
 };

package/dist/rateLimiting.d.ts

@@ -1,66 +1,12 @@
 import type { RouteContext, RateLimitingParams } from '@aeriajs/types';
 import { Result, HTTPStatus, RateLimitingError } from '@aeriajs/types';
-export declare const getOrCreateUsageEntry: (params: RateLimitingParams, context: RouteContext) => Promise<import("@aeriajs/types").WithId<Omit<import("@aeriajs/types").PackReferences<import("@aeriajs/types").SchemaWithId<{
-    readonly $id: "resourceUsage";
-    readonly icon: "wrench";
-    readonly required: readonly ["usage"];
-    readonly properties: {
-        readonly user: {
-            readonly $ref: "user";
-        };
-        readonly address: {
-            readonly type: "string";
-        };
-        readonly usage: {
-            readonly type: "object";
-            readonly additionalProperties: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly hits: {
-                        readonly type: "integer";
-                    };
-                    readonly points: {
-                        readonly type: "integer";
-                    };
-                    readonly last_reach: {
-                        readonly type: "string";
-                        readonly format: "date-time";
-                    };
-                    readonly last_maximum_reach: {
-                        readonly type: "string";
-                        readonly format: "date-time";
-                    };
-                };
-            };
-        };
-    };
-}>>, "_id">>>;
-export declare const limitRate: (params: RateLimitingParams, context: RouteContext) => Promise<Result.Error<{
+export declare const getOrCreateUsageEntry: (params: RateLimitingParams, context: RouteContext) => Promise<import("@aeriajs/types").WithId<Omit<import("@aeriajs/types").PackReferences<import("@aeriajs/types").SchemaWithId<import("@aeriajs/types").Description>>, "_id">>>;
+export declare const limitRate: (params: RateLimitingParams, context: RouteContext) => Promise<{
+    readonly _tag: "Result";
+    readonly error: undefined;
+    readonly result: any;
+} | Result.Error<{
     readonly code: RateLimitingError.LimitReached;
 } & {
     httpStatus: HTTPStatus.TooManyRequests;
-}> | {
-    readonly _tag: "Result";
-    readonly error: undefined;
-    readonly result: import("@aeriajs/types").PackReferences<{} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
-        readonly hits: {
-            readonly type: "integer";
-        };
-        readonly points: {
-            readonly type: "integer";
-        };
-        readonly last_reach: {
-            readonly type: "string";
-            readonly format: "date-time";
-        };
-        readonly last_maximum_reach: {
-            readonly type: "string";
-            readonly format: "date-time";
-        };
-    }>> & {
-        hits: number;
-        points: number;
-        last_reach: Date;
-        last_maximum_reach: Date;
-    }, never>>;
-}>;
+}>>;

package/dist/use.d.ts

@@ -1,7 +1,25 @@
-import type { Context, Description, ACError } from '@aeriajs/types';
-import type { CollectionHookReadPayload, CollectionHookWritePayload } from './types.js';
-import { Result } from '@aeriajs/types';
+import type { Context, Description, ACError, CollectionReadPayload, CollectionWritePayload } from '@aeriajs/types';
 export declare const useSecurity: <TDescription extends Description>(context: Context<TDescription>) => {
-    secureReadPayload: <TPayload extends Partial<CollectionHookReadPayload>>(payload?: TPayload) => Promise<Result.Either<ACError.InvalidLimit | ACError.OwnershipError, TPayload & CollectionHookReadPayload>>;
-    secureWritePayload: <TPayload extends CollectionHookWritePayload>(payload?: TPayload) => Promise<Result.Either<ACError.TargetImmutable | ACError.OwnershipError | ACError.ResourceNotFound, TPayload>>;
+    secureReadPayload: <TPayload extends Partial<CollectionReadPayload>>(payload?: TPayload) => Promise<{
+        readonly _tag: "Error";
+        readonly error: ACError.InvalidLimit | ACError.OwnershipError;
+        readonly result: undefined;
+    } | {
+        readonly _tag: "Result";
+        readonly error: undefined;
+        readonly result: {
+            filters: {};
+        } & TPayload;
+    }>;
+    secureWritePayload: <TPayload extends CollectionWritePayload>(payload?: TPayload) => Promise<{
+        readonly _tag: "Error";
+        readonly error: ACError.TargetImmutable | ACError.OwnershipError | ACError.ResourceNotFound;
+        readonly result: undefined;
+    } | {
+        readonly _tag: "Result";
+        readonly error: undefined;
+        readonly result: {
+            what: {};
+        } & TPayload;
+    }>;
 };

package/dist/use.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSecurity = void 0;
 const types_1 = require("@aeriajs/types");
-const middleware_js_1 = require("./middleware.js");
-const index_js_1 = require("./middlewares/index.js");
+const index_js_1 = require("./middleware/index.js");
+const index_js_2 = require("./middlewares/index.js");
 const useSecurity = (context) => {
     const secureReadPayload = async (payload) => {
         const newPayload = Object.assign({
@@ -12,12 +12,15 @@ const useSecurity = (context) => {
         const props = {
             payload: newPayload,
         };
-        const middlewares = [index_js_1.checkPagination];
-        if (context.description.owned !== 'on-write') {
-            middlewares.push(index_js_1.checkOwnershipRead);
+        const start = (0, index_js_1.iterableMiddlewares)([
+            index_js_2.checkPagination,
+            index_js_2.checkOwnershipRead,
+        ]);
+        const { error, result } = await start(types_1.Result.result(props), context);
+        if (error) {
+            return types_1.Result.error(error);
         }
-        const start = (0, middleware_js_1.iterableMiddlewares)(middlewares);
-        return start(props, types_1.Result.result(newPayload), context);
+        return types_1.Result.result(result.payload);
     };
     const secureWritePayload = async (payload) => {
         const newPayload = Object.assign({
@@ -26,11 +29,15 @@ const useSecurity = (context) => {
         const props = {
             payload: newPayload,
         };
-        const start = (0, middleware_js_1.iterableMiddlewares)([
-            index_js_1.checkOwnershipWrite,
-            index_js_1.checkImmutabilityWrite,
+        const start = (0, index_js_1.iterableMiddlewares)([
+            index_js_2.checkOwnershipWrite,
+            index_js_2.checkImmutabilityWrite,
         ]);
-        return start(props, types_1.Result.result(newPayload), context);
+        const { error, result } = await start(types_1.Result.result(props), context);
+        if (error) {
+            return types_1.Result.error(error);
+        }
+        return types_1.Result.result(result.payload);
     };
     return {
         secureReadPayload,

package/dist/use.mjs

@@ -1,6 +1,6 @@
 "use strict";
 import { Result } from "@aeriajs/types";
-import { iterableMiddlewares } from "./middleware.mjs";
+import { iterableMiddlewares } from "./middleware/index.mjs";
 import {
   checkImmutabilityWrite,
   checkOwnershipRead,
@@ -15,12 +15,15 @@ export const useSecurity = (context) => {
     const props = {
       payload: newPayload
     };
-    const middlewares = [checkPagination];
-    if (context.description.owned !== "on-write") {
-      middlewares.push(checkOwnershipRead);
+    const start = iterableMiddlewares([
+      checkPagination,
+      checkOwnershipRead
+    ]);
+    const { error, result } = await start(Result.result(props), context);
+    if (error) {
+      return Result.error(error);
     }
-    const start = iterableMiddlewares(middlewares);
-    return start(props, Result.result(newPayload), context);
+    return Result.result(result.payload);
   };
   const secureWritePayload = async (payload) => {
     const newPayload = Object.assign({
@@ -33,7 +36,11 @@ export const useSecurity = (context) => {
       checkOwnershipWrite,
       checkImmutabilityWrite
     ]);
-    return start(props, Result.result(newPayload), context);
+    const { error, result } = await start(Result.result(props), context);
+    if (error) {
+      return Result.error(error);
+    }
+    return Result.result(result.payload);
   };
   return {
     secureReadPayload,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/security",
-  "version": "0.0.162",
+  "version": "0.0.163",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -28,13 +28,13 @@
     "mongodb": "^6.5.0"
   },
   "peerDependencies": {
-    "@aeriajs/core": "^0.0.162",
-    "@aeriajs/common": "^0.0.98",
-    "@aeriajs/types": "^0.0.84",
+    "@aeriajs/core": "^0.0.163",
+    "@aeriajs/common": "^0.0.99",
+    "@aeriajs/types": "^0.0.85",
     "mongodb": "^6.5.0"
   },
   "scripts": {
-    "test": "echo skipping",
+    "test": "vitest run",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
     "build": "pnpm build:cjs && pnpm build:esm",

package/dist/middleware.d.ts

@@ -1,2 +0,0 @@
-import type { Middleware, MiddlewareNext, GenericMiddlewareNext, Context } from '@aeriajs/types';
-export declare const iterableMiddlewares: <TReturn, TPayload, TReturnNext extends GenericMiddlewareNext<TReturn, TPayload> = MiddlewareNext>(middlewares: Middleware<TReturn, TPayload, TReturnNext>[], end?: (_: unknown, initial: TReturn) => TReturn) => (payload: TPayload, initial: TReturn, context: Context) => TReturn | Promise<TReturn>;

package/dist/types.d.ts

@@ -1,9 +0,0 @@
-export type CollectionHookReadPayload = {
-    filters: Record<string, any>;
-    sort?: Record<string, any>;
-    limit?: number;
-    offset?: number;
-};
-export type CollectionHookWritePayload = {
-    what: Record<string, any>;
-};

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.mjs

@@ -1 +0,0 @@
-"use strict";