@imqueue/pg-sequelize 4.2.0

package/src/types/FilterInput.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Maps each `$`-prefixed filter operator to the Sequelize `Op` symbol it means.
+ *
+ * @remarks
+ * This mapping is the reason {@link FilterInput} exists at all. Sequelize's
+ * operators are ES symbols, and a symbol cannot be serialized — so a filter built
+ * with `Op.gt` on a client would arrive at the service as an empty object. The
+ * remote caller sends the string `$gt` instead, and `query.toWhereOptions` swaps in
+ * the symbol on this side.
+ *
+ * Only the operators listed here are translated. Any other key is passed through as
+ * written, on the assumption that it is a column name — so a mistyped `$gtt` becomes
+ * a filter on a column called `$gtt` rather than an error.
+ */
+export declare const FILTER_OPS: {
+    $and: symbol;
+    $or: symbol;
+    $gt: symbol;
+    $gte: symbol;
+    $lt: symbol;
+    $lte: symbol;
+    $ne: symbol;
+    $eq: symbol;
+    $not: symbol;
+    $between: symbol;
+    $notBetween: symbol;
+    $in: symbol;
+    $notIn: symbol;
+    $like: symbol;
+    $notLike: symbol;
+    $iLike: symbol;
+    $notILike: symbol;
+    $regexp: symbol;
+    $notRegexp: symbol;
+    $iRegexp: symbol;
+    $notIRegexp: symbol;
+    $overlap: symbol;
+    $contains: symbol;
+    $contained: symbol;
+    $any: symbol;
+    $adjacent: symbol;
+    $strictLeft: symbol;
+    $strictRight: symbol;
+    $noExtendRight: symbol;
+    $noExtendLeft: symbol;
+};
+/**
+ * A where clause as plain, serializable JSON.
+ *
+ * @remarks
+ * Gives a remote caller the same expressive power Sequelize offers locally —
+ * comparison, set membership, pattern matching, regular expressions and range
+ * operators, nested arbitrarily through `$and` and `$or`. Every operator is a
+ * `$`-prefixed string rather than a symbol, because symbols do not survive the wire;
+ * {@link FILTER_OPS} does the translation on arrival.
+ *
+ * Two things follow from how `query.toWhereOptions` walks it. Keys are read
+ * recursively, so a value that is itself an object is treated as a nested filter and
+ * only a non-object value ends the walk. And any key that is NOT a known operator is
+ * kept verbatim as a column name — which is what lets you mix columns and operators
+ * in one object, and also means a typo becomes a column rather than a complaint.
+ *
+ * The declared property types are the common cases rather than hard limits; the
+ * runtime walk does not enforce them.
+ *
+ * @example
+ * ```typescript
+ * // type is 'fast' or 'std', and the reservation was created this year
+ * const filter = {
+ *     $or: [{ type: 'fast' }, { type: 'std' }],
+ *     createdAt: { $gte: '2026-01-01' },
+ * } as FilterInput;
+ * ```
+ */
+export declare class FilterInput {
+    /** Every nested condition must hold (SQL `AND`). */
+    $and?: FilterInput | Array<FilterInput | number | string | boolean | null>;
+    /** At least one nested condition must hold (SQL `OR`). */
+    $or?: FilterInput | Array<FilterInput | number | string | boolean | null>;
+    /** Greater than. */
+    $gt?: number;
+    /** Greater than or equal to. */
+    $gte?: number;
+    /** Less than. */
+    $lt?: number;
+    /** Less than or equal to. */
+    $lte?: number;
+    /** Not equal to. */
+    $ne?: number | string;
+    /** Equal to. With `null`, becomes `IS NULL`. */
+    $eq?: number | string | boolean | null;
+    /** Negates the nested condition (SQL `NOT`). */
+    $not?: boolean;
+    /** Within the inclusive `[low, high]` pair (SQL `BETWEEN`). */
+    $between?: Array<number | string>;
+    /** Outside the inclusive `[low, high]` pair. */
+    $notBetween?: Array<number | string>;
+    /** One of the listed values (SQL `IN`). An empty list matches nothing. */
+    $in?: Array<number | string | boolean | null>;
+    /** None of the listed values (SQL `NOT IN`). */
+    $notIn?: Array<number | string | boolean | null>;
+    /** Case-sensitive pattern match, `%` and `_` as wildcards (SQL `LIKE`). */
+    $like?: string;
+    /** Fails a case-sensitive pattern match. */
+    $notLike?: string;
+    /** Case-insensitive pattern match (Postgres `ILIKE`). */
+    $iLike?: string;
+    /** Fails a case-insensitive pattern match. */
+    $notILike?: string;
+    /** Matches a POSIX regular expression (Postgres `~`). */
+    $regexp?: string;
+    /** Fails a POSIX regular expression (Postgres `!~`). */
+    $notRegexp?: string;
+    /** Matches a regular expression, case-insensitively (Postgres `~*`). */
+    $iRegexp?: string;
+    /** Fails a case-insensitive regular expression (Postgres `!~*`). */
+    $notIRegexp?: string;
+    /** Ranges share at least one value (Postgres `&&`). */
+    $overlap?: [number, number];
+    /** The column's range contains this value or range (Postgres `@>`). */
+    $contains?: number | [number, number];
+    /** The column's range is contained by this one (Postgres `<@`). */
+    $contained?: [number, number];
+    /** Equals any element of the array (Postgres `= ANY`). */
+    $any?: number[] | string[];
+    /** Ranges touch without overlapping (Postgres `-|-`). */
+    $adjacent?: [number, number];
+    /** Range lies entirely to the left of this one (Postgres `<<`). */
+    $strictLeft?: [number, number];
+    /** Range lies entirely to the right of this one (Postgres `>>`). */
+    $strictRight?: [number, number];
+    /** Range does not extend past this one's right bound (Postgres `&<`). */
+    $noExtendRight?: [number, number];
+    /** Range does not extend past this one's left bound (Postgres `&>`). */
+    $noExtendLeft?: [number, number];
+}

package/src/types/FilterInput.js

@@ -0,0 +1,291 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import { property } from '@imqueue/rpc';
+import { Op } from 'sequelize';
+/**
+ * Maps each `$`-prefixed filter operator to the Sequelize `Op` symbol it means.
+ *
+ * @remarks
+ * This mapping is the reason {@link FilterInput} exists at all. Sequelize's
+ * operators are ES symbols, and a symbol cannot be serialized — so a filter built
+ * with `Op.gt` on a client would arrive at the service as an empty object. The
+ * remote caller sends the string `$gt` instead, and `query.toWhereOptions` swaps in
+ * the symbol on this side.
+ *
+ * Only the operators listed here are translated. Any other key is passed through as
+ * written, on the assumption that it is a column name — so a mistyped `$gtt` becomes
+ * a filter on a column called `$gtt` rather than an error.
+ */
+export const FILTER_OPS = {
+    $and: Op.and,
+    $or: Op.or,
+    $gt: Op.gt,
+    $gte: Op.gte,
+    $lt: Op.lt,
+    $lte: Op.lte,
+    $ne: Op.ne,
+    $eq: Op.eq,
+    $not: Op.not,
+    $between: Op.between,
+    $notBetween: Op.notBetween,
+    $in: Op.in,
+    $notIn: Op.notIn,
+    $like: Op.like,
+    $notLike: Op.notLike,
+    $iLike: Op.iLike,
+    $notILike: Op.notILike,
+    $regexp: Op.regexp,
+    $notRegexp: Op.notRegexp,
+    $iRegexp: Op.iRegexp,
+    $notIRegexp: Op.notIRegexp,
+    $overlap: Op.overlap,
+    $contains: Op.contains,
+    $contained: Op.contained,
+    $any: Op.any,
+    $adjacent: Op.adjacent,
+    $strictLeft: Op.strictLeft,
+    $strictRight: Op.strictRight,
+    $noExtendRight: Op.noExtendRight,
+    $noExtendLeft: Op.noExtendLeft,
+};
+/**
+ * A where clause as plain, serializable JSON.
+ *
+ * @remarks
+ * Gives a remote caller the same expressive power Sequelize offers locally —
+ * comparison, set membership, pattern matching, regular expressions and range
+ * operators, nested arbitrarily through `$and` and `$or`. Every operator is a
+ * `$`-prefixed string rather than a symbol, because symbols do not survive the wire;
+ * {@link FILTER_OPS} does the translation on arrival.
+ *
+ * Two things follow from how `query.toWhereOptions` walks it. Keys are read
+ * recursively, so a value that is itself an object is treated as a nested filter and
+ * only a non-object value ends the walk. And any key that is NOT a known operator is
+ * kept verbatim as a column name — which is what lets you mix columns and operators
+ * in one object, and also means a typo becomes a column rather than a complaint.
+ *
+ * The declared property types are the common cases rather than hard limits; the
+ * runtime walk does not enforce them.
+ *
+ * @example
+ * ```typescript
+ * // type is 'fast' or 'std', and the reservation was created this year
+ * const filter = {
+ *     $or: [{ type: 'fast' }, { type: 'std' }],
+ *     createdAt: { $gte: '2026-01-01' },
+ * } as FilterInput;
+ * ```
+ */
+export class FilterInput {
+    /** Every nested condition must hold (SQL `AND`). */
+    $and;
+    /** At least one nested condition must hold (SQL `OR`). */
+    $or;
+    /** Greater than. */
+    $gt;
+    /** Greater than or equal to. */
+    $gte;
+    /** Less than. */
+    $lt;
+    /** Less than or equal to. */
+    $lte;
+    /** Not equal to. */
+    $ne;
+    /** Equal to. With `null`, becomes `IS NULL`. */
+    $eq;
+    /** Negates the nested condition (SQL `NOT`). */
+    $not;
+    /** Within the inclusive `[low, high]` pair (SQL `BETWEEN`). */
+    $between;
+    /** Outside the inclusive `[low, high]` pair. */
+    $notBetween;
+    /** One of the listed values (SQL `IN`). An empty list matches nothing. */
+    $in;
+    /** None of the listed values (SQL `NOT IN`). */
+    $notIn;
+    /** Case-sensitive pattern match, `%` and `_` as wildcards (SQL `LIKE`). */
+    $like;
+    /** Fails a case-sensitive pattern match. */
+    $notLike;
+    /** Case-insensitive pattern match (Postgres `ILIKE`). */
+    $iLike;
+    /** Fails a case-insensitive pattern match. */
+    $notILike;
+    /** Matches a POSIX regular expression (Postgres `~`). */
+    $regexp;
+    /** Fails a POSIX regular expression (Postgres `!~`). */
+    $notRegexp;
+    /** Matches a regular expression, case-insensitively (Postgres `~*`). */
+    $iRegexp;
+    /** Fails a case-insensitive regular expression (Postgres `!~*`). */
+    $notIRegexp;
+    /** Ranges share at least one value (Postgres `&&`). */
+    $overlap;
+    /** The column's range contains this value or range (Postgres `@>`). */
+    $contains;
+    /** The column's range is contained by this one (Postgres `<@`). */
+    $contained;
+    /** Equals any element of the array (Postgres `= ANY`). */
+    $any;
+    /** Ranges touch without overlapping (Postgres `-|-`). */
+    $adjacent;
+    /** Range lies entirely to the left of this one (Postgres `<<`). */
+    $strictLeft;
+    /** Range lies entirely to the right of this one (Postgres `>>`). */
+    $strictRight;
+    /** Range does not extend past this one's right bound (Postgres `&<`). */
+    $noExtendRight;
+    /** Range does not extend past this one's left bound (Postgres `&>`). */
+    $noExtendLeft;
+}
+__decorate([
+    property('FilterInput | Array<FilterInput|number|string|boolean|null>', true),
+    __metadata("design:type", Object)
+], FilterInput.prototype, "$and", void 0);
+__decorate([
+    property('FilterInput | Array<FilterInput|number|string|boolean|null>', true),
+    __metadata("design:type", Object)
+], FilterInput.prototype, "$or", void 0);
+__decorate([
+    property('number', true),
+    __metadata("design:type", Number)
+], FilterInput.prototype, "$gt", void 0);
+__decorate([
+    property('number', true),
+    __metadata("design:type", Number)
+], FilterInput.prototype, "$gte", void 0);
+__decorate([
+    property('number', true),
+    __metadata("design:type", Number)
+], FilterInput.prototype, "$lt", void 0);
+__decorate([
+    property('number', true),
+    __metadata("design:type", Number)
+], FilterInput.prototype, "$lte", void 0);
+__decorate([
+    property('number | string', true),
+    __metadata("design:type", Object)
+], FilterInput.prototype, "$ne", void 0);
+__decorate([
+    property('number | string | boolean | null', true),
+    __metadata("design:type", Object)
+], FilterInput.prototype, "$eq", void 0);
+__decorate([
+    property('boolean', true),
+    __metadata("design:type", Boolean)
+], FilterInput.prototype, "$not", void 0);
+__decorate([
+    property('Array<number | string>', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$between", void 0);
+__decorate([
+    property('Array<number | string>', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$notBetween", void 0);
+__decorate([
+    property('Array<number | string | boolean | null>', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$in", void 0);
+__decorate([
+    property('Array<number | string | boolean | null>', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$notIn", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$like", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$notLike", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$iLike", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$notILike", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$regexp", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$notRegexp", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$iRegexp", void 0);
+__decorate([
+    property('string', true),
+    __metadata("design:type", String)
+], FilterInput.prototype, "$notIRegexp", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$overlap", void 0);
+__decorate([
+    property('number | [number, number]', true),
+    __metadata("design:type", Object)
+], FilterInput.prototype, "$contains", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$contained", void 0);
+__decorate([
+    property('number[] | string[]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$any", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$adjacent", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$strictLeft", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$strictRight", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$noExtendRight", void 0);
+__decorate([
+    property('[number, number]', true),
+    __metadata("design:type", Array)
+], FilterInput.prototype, "$noExtendLeft", void 0);
+//# sourceMappingURL=FilterInput.js.map

package/src/types/JsonObject.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A free-form object, describable to `@imqueue/rpc`.
+ *
+ * @remarks
+ * For the places where the shape genuinely is not known ahead of time — a `jsonb`
+ * column, a settings blob, a passthrough payload. `@indexed` gives it an RPC
+ * description, which a bare `Record<string, any>` cannot have: the RPC layer builds
+ * its service description from decorated classes, so an anonymous type would arrive
+ * at the client as nothing at all.
+ *
+ * Reach for it only when that is true. Every property typed this way is one the
+ * generated client cannot check.
+ */
+export declare class JsonObject {
+    [property: string]: any;
+}

package/src/types/JsonObject.js

@@ -0,0 +1,50 @@
+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;
+};
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import { indexed } from '@imqueue/rpc';
+/**
+ * A free-form object, describable to `@imqueue/rpc`.
+ *
+ * @remarks
+ * For the places where the shape genuinely is not known ahead of time — a `jsonb`
+ * column, a settings blob, a passthrough payload. `@indexed` gives it an RPC
+ * description, which a bare `Record<string, any>` cannot have: the RPC layer builds
+ * its service description from decorated classes, so an anonymous type would arrive
+ * at the client as nothing at all.
+ *
+ * Reach for it only when that is true. Every property typed this way is one the
+ * generated client cannot check.
+ */
+let JsonObject = class JsonObject {
+};
+JsonObject = __decorate([
+    indexed(() => `[property: string]: any`)
+], JsonObject);
+export { JsonObject };
+//# sourceMappingURL=JsonObject.js.map

package/src/types/OrderByInput.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The two directions a column can be ordered in.
+ *
+ * @remarks
+ * The values are the SQL keywords, so they can be handed to Sequelize as they are.
+ */
+export declare enum OrderDirection {
+    /** Ascending — also what any unrecognised direction becomes. */
+    asc = "ASC",
+    /** Descending. */
+    desc = "DESC"
+}
+/**
+ * The `OrderDirection` values as an `@imqueue/rpc` type description.
+ *
+ * @remarks
+ * `'ASC' | 'DESC'`, built from the enum so the description cannot drift from it.
+ * Used in the `@indexed` description of {@link OrderByInput}, and available for your
+ * own `@property` declarations that accept a direction.
+ */
+export declare const ENUM_ORDER_DIRECTION = "'ASC' | 'DESC'";
+/**
+ * Which columns to order by, and in which direction.
+ *
+ * @remarks
+ * Keyed by column name; `query.toOrderOptions` turns it into Sequelize's `order`
+ * array, preserving the key order of the object, so the first key is the primary
+ * sort.
+ *
+ * Direction values are coerced rather than validated: anything that does not read
+ * as `desc`, case-insensitively, becomes ascending. That is deliberate — the value
+ * arrives from a remote caller and ends up in SQL, so an unrecognised direction has
+ * to become a safe default rather than being passed through. It does mean a typo
+ * silently sorts the other way.
+ *
+ * Column names are NOT coerced, and they reach the query as given.
+ *
+ * @example
+ * ```typescript
+ * const orderBy: OrderByInput = { type: OrderDirection.asc, createdAt: OrderDirection.desc };
+ * ```
+ */
+export declare class OrderByInput {
+    [fieldName: string]: OrderDirection;
+}

package/src/types/OrderByInput.js

@@ -0,0 +1,80 @@
+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;
+};
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import { indexed } from '@imqueue/rpc';
+/**
+ * The two directions a column can be ordered in.
+ *
+ * @remarks
+ * The values are the SQL keywords, so they can be handed to Sequelize as they are.
+ */
+export var OrderDirection;
+(function (OrderDirection) {
+    /** Ascending — also what any unrecognised direction becomes. */
+    OrderDirection["asc"] = "ASC";
+    /** Descending. */
+    OrderDirection["desc"] = "DESC";
+})(OrderDirection || (OrderDirection = {}));
+/**
+ * The `OrderDirection` values as an `@imqueue/rpc` type description.
+ *
+ * @remarks
+ * `'ASC' | 'DESC'`, built from the enum so the description cannot drift from it.
+ * Used in the `@indexed` description of {@link OrderByInput}, and available for your
+ * own `@property` declarations that accept a direction.
+ */
+export const ENUM_ORDER_DIRECTION = `'${OrderDirection.asc}' | '${OrderDirection.desc}'`;
+/**
+ * Which columns to order by, and in which direction.
+ *
+ * @remarks
+ * Keyed by column name; `query.toOrderOptions` turns it into Sequelize's `order`
+ * array, preserving the key order of the object, so the first key is the primary
+ * sort.
+ *
+ * Direction values are coerced rather than validated: anything that does not read
+ * as `desc`, case-insensitively, becomes ascending. That is deliberate — the value
+ * arrives from a remote caller and ends up in SQL, so an unrecognised direction has
+ * to become a safe default rather than being passed through. It does mean a typo
+ * silently sorts the other way.
+ *
+ * Column names are NOT coerced, and they reach the query as given.
+ *
+ * @example
+ * ```typescript
+ * const orderBy: OrderByInput = { type: OrderDirection.asc, createdAt: OrderDirection.desc };
+ * ```
+ */
+let OrderByInput = class OrderByInput {
+};
+OrderByInput = __decorate([
+    indexed(() => `[fieldName: string]: ${ENUM_ORDER_DIRECTION}`)
+], OrderByInput);
+export { OrderByInput };
+//# sourceMappingURL=OrderByInput.js.map

package/src/types/PaginationInput.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Where a page starts and how big it is.
+ *
+ * @remarks
+ * Turned into Sequelize's `offset`/`limit` by `query.toLimitOptions`, which treats
+ * this input as advisory rather than authoritative — see the notes on each property.
+ * A negative `limit` is the interesting case: it means "the last N rows", and it is
+ * the only reason `count` exists.
+ */
+export declare class PaginationInput {
+    /**
+     * Rows to skip before the page starts.
+     *
+     * @remarks
+     * Ignored when `limit` is absent or zero, since there is then no page to
+     * position. With a negative `limit` and an `offset` of zero it is computed
+     * instead — see `limit`.
+     */
+    offset: number;
+    /**
+     * Rows in the page. Negative counts back from the end of the set.
+     *
+     * @remarks
+     * Zero, absent or non-numeric means no pagination at all: `toLimitOptions`
+     * returns an empty options object and the query is left unbounded. That is a
+     * quiet default worth knowing about — a caller who sends `limit: 0` expecting
+     * "no rows" gets every row.
+     *
+     * A negative value takes the absolute value as the page size and, when `offset`
+     * is zero, positions the window at the end of the set: `count - limit`, clamped
+     * at zero. So `{ limit: -10, count: 1340 }` is the last ten rows. Without a
+     * `count` the offset computes to a negative number and clamps to zero, giving
+     * the FIRST ten rows rather than the last — the two properties go together.
+     */
+    limit: number;
+    /**
+     * Total rows in the set, used only to place a negative `limit`.
+     *
+     * @remarks
+     * Nothing validates it against the real total, and it is ignored entirely for a
+     * positive `limit`.
+     */
+    count?: number;
+}