quetch 0.2.1 → 0.3.0

package/lib/types/FilterString.ts

@@ -0,0 +1,19 @@
+import type { FilterKeys } from "./FilterKeys";
+
+/**
+ * Checks if a given string field matches a given string value according to a given operator.
+ */
+export type FilterString<T extends object> = {
+  operator:
+    | "equal"
+    | "notEqual"
+    | "startWith"
+    | "endWith"
+    | "include"
+    | "greaterThan"
+    | "greaterThanOrEqual"
+    | "lowerThan"
+    | "lowerThanOrEqual";
+  field: FilterKeys<T, string>;
+  value: string;
+};

package/lib/types/FilterStringIntersect.ts

@@ -0,0 +1,10 @@
+import type { FilterKeys } from "./FilterKeys";
+
+/**
+ * Checks if a given string field has any of the provided values.
+ */
+export type FilterStringIntersect<T extends object> = {
+  operator: "intersect";
+  field: FilterKeys<T, string>;
+  value: string[];
+};

package/lib/types/FilterStringMatch.ts

@@ -0,0 +1,30 @@
+import type { FilterKeys } from "./FilterKeys";
+
+/**
+ * Checks if a given string field matches a given regular expression.
+ */
+export type FilterStringMatch<T extends object> = {
+  operator: "match";
+  field: FilterKeys<T, string>;
+  /**
+   * Raw regular expression string.
+   */
+  value: string;
+  /**
+   * Regular expression options.
+   */
+  options?: {
+    /**
+     * When matching, casing differences are ignored.
+     */
+    ignoreCase?: boolean;
+    /**
+     * Allows . to match newlines.
+     */
+    dotAll?: boolean;
+  };
+  /**
+   * Compiled regular expression generated by the `testFilter` function.
+   */
+  regularExpression?: RegExp;
+};

package/lib/types/Get.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the type of the property at the specified `K` key.
+ */
+export type Get<T extends object, K extends string, D> = T extends {
+  [key in K]: any;
+}
+  ? T[K]
+  : D;

package/lib/types/Group.ts

@@ -0,0 +1,11 @@
+import type { CustomFieldAggregateMap } from "./CustomFieldAggregateMap";
+
+/**
+ * Specifies how items should be grouped.
+ */
+export type Group<T extends object> =
+  | keyof T
+  | {
+      field: keyof T;
+      customFields?: CustomFieldAggregateMap<T>;
+    };

package/lib/types/Handler.ts

@@ -0,0 +1,9 @@
+import type { NextHandler } from "./NextHandler";
+
+/**
+ * Handles an `input` query and returns an `output` promise, eventually using the `next` handler.
+ */
+export type Handler<I, O, NI, No> = (
+  input: I,
+  next: NextHandler<NI, No>,
+) => Promise<O>;

package/lib/types/Immutable.ts

@@ -0,0 +1,3 @@
+export type Immutable<T extends object> = {
+  readonly [K in keyof T]: T[K];
+};

package/lib/types/InjectCustomFields.ts

@@ -0,0 +1,23 @@
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { FieldFunctionCustom } from "./FieldFunctionCustom";
+import type { FieldFunctionReturn } from "./FieldFunctionReturn";
+
+/**
+ * Injects the custom fields into the entity type.
+ */
+export type InjectCustomFields<
+  T extends object,
+  C extends CustomFieldMap<T> | undefined,
+> = C extends CustomFieldMap<T>
+  ? {
+      readonly [K in keyof T | keyof C]: K extends keyof T
+        ? T[K]
+        : K extends keyof C
+        ? C[K] extends FieldFunctionCustom<T>
+          ? ReturnType<C[K]["value"]>
+          : C[K]["operator"] extends keyof FieldFunctionReturn
+          ? FieldFunctionReturn[C[K]["operator"]]
+          : never
+        : never;
+    }
+  : T;

package/lib/types/Item.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the inferred item type of an array, or an alternative type if it is something else (e.g., `undefined`).
+ */
+export type Item<T, S = undefined> = T extends Array<infer I>
+  ? I
+  : T extends ReadonlyArray<infer I>
+  ? I
+  : S;

package/lib/types/Key.ts

@@ -0,0 +1 @@
+export type Key = string | number | symbol;

package/lib/types/Mutable.ts

@@ -0,0 +1,3 @@
+export type Mutable<T extends object> = {
+  -readonly [K in keyof T]: T[K];
+};

package/lib/types/NextHandler.ts

@@ -0,0 +1,4 @@
+/**
+ * Handles an `input` query and returns an `output` promise.
+ */
+export type NextHandler<I, R> = (input: I) => Promise<R>;

package/lib/types/Order.ts

@@ -0,0 +1,9 @@
+/**
+ * Order item.
+ */
+export type Order<T extends object> =
+  | keyof T
+  | {
+      field: keyof T;
+      descending?: boolean;
+    };

package/lib/types/Query.ts

@@ -0,0 +1,36 @@
+import type { Context } from "./Context";
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { InjectCustomFields } from "./InjectCustomFields";
+import type { QueryAggregate } from "./QueryAggregate";
+import type { QueryCreate } from "./QueryCreate";
+import type { QueryCreateMultiple } from "./QueryCreateMultiple";
+import type { QueryDelete } from "./QueryDelete";
+import type { QueryDeleteMultiple } from "./QueryDeleteMultiple";
+import type { QueryRead } from "./QueryRead";
+import type { QueryReadMultiple } from "./QueryReadMultiple";
+import type { QueryUpdate } from "./QueryUpdate";
+import type { QueryUpdateMultiple } from "./QueryUpdateMultiple";
+
+type QueryBase<T extends object> =
+  | QueryRead<T>
+  | QueryReadMultiple<T>
+  | QueryCreate<T>
+  | QueryCreateMultiple<T>
+  | QueryUpdate<T>
+  | QueryUpdateMultiple<T>
+  | QueryDelete<T>
+  | QueryDeleteMultiple<T>
+  | QueryAggregate<T>;
+
+/**
+ * Query that fetches or mutates an entity.
+ */
+export type Query<
+  T extends object,
+  C extends CustomFieldMap<T> | undefined,
+> = QueryBase<InjectCustomFields<T, C>> & {
+  /**
+   * Common item properties to use for identifying the item.
+   */
+  context?: Context<T>;
+};

package/lib/types/QueryAggregate.ts

@@ -0,0 +1,11 @@
+import type { AggregateFunction } from "./AggregateFunction";
+import type { Filter } from "./Filter";
+
+/**
+ * Query for computing an aggregated value.
+ */
+export type QueryAggregate<T extends object> = {
+  method: "aggregate";
+  aggregator: AggregateFunction<T>;
+  filter?: Filter<T>;
+};

package/lib/types/QueryAny.ts

@@ -0,0 +1,8 @@
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { Key } from "./Key";
+import type { Query } from "./Query";
+
+export type QueryAny = Query<any, any> & {
+  type: Key | any[];
+  customFields?: CustomFieldMap<any>;
+};

package/lib/types/QueryCreate.ts

@@ -0,0 +1,7 @@
+/**
+ * Query for creating an item.
+ */
+export type QueryCreate<T extends object> = {
+  method: "create";
+  value: Partial<T>;
+};

package/lib/types/QueryCreateMultiple.ts

@@ -0,0 +1,8 @@
+/**
+ * Query for creating multiple items.
+ */
+export type QueryCreateMultiple<T extends object> = {
+  method: "create";
+  multiple: true;
+  value: Partial<T>[];
+};

package/lib/types/QueryDelete.ts

@@ -0,0 +1,11 @@
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { Filter } from "./Filter";
+
+/**
+ * Query for deleting an item.
+ */
+export type QueryDelete<T extends object> = {
+  method: "delete";
+  filter?: Filter<T>;
+  customFields?: CustomFieldMap<T>;
+};

package/lib/types/QueryDeleteMultiple.ts

@@ -0,0 +1,12 @@
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { Filter } from "./Filter";
+
+/**
+ * Query for deleting multiple items.
+ */
+export type QueryDeleteMultiple<T extends object> = {
+  method: "delete";
+  multiple: true;
+  filter?: Filter<T>;
+  customFields?: CustomFieldMap<T>;
+};

package/lib/types/QueryMethod.ts

@@ -0,0 +1,6 @@
+import type { Query } from "./Query";
+
+/**
+ * Available query methods.
+ */
+export type QueryMethod = Exclude<Query<never, never>["method"], undefined>;

package/lib/types/QueryRead.ts

@@ -0,0 +1,24 @@
+import type { Filter } from "./Filter";
+import type { Order } from "./Order";
+
+/**
+ * Query for reading a single item.
+ */
+export type QueryRead<T extends object> = {
+  method?: "read";
+  multiple?: false;
+  offset?: never;
+  group?: never;
+  /**
+   * Item fields to pick. If omitted, all fields are picked.
+   */
+  fields?: readonly (keyof T)[];
+  /**
+   * Filter for finding the item, if it cannot be found based on the `context`.
+   */
+  filter?: Filter<T>;
+  /**
+   * Order by which the items should be sorted.
+   */
+  order?: Order<T>[];
+};

package/lib/types/QueryReadMultiple.ts

@@ -0,0 +1,36 @@
+import type { Filter } from "./Filter";
+import type { Group } from "./Group";
+import type { Order } from "./Order";
+
+/**
+ * Query for getting a list of items.
+ */
+export type QueryReadMultiple<T extends object> = {
+  method?: "read";
+  multiple: true;
+  /**
+   * Offset of the first matching item.
+   */
+  offset?: number;
+  /**
+   * Upper bound of the number of items to return.
+   */
+  limit?: number;
+
+  /**
+   * Item fields to pick. If omitted, all fields are picked.
+   */
+  fields?: readonly (keyof T)[];
+  /**
+   * Filter that picks the items.
+   */
+  filter?: Filter<T>;
+  /**
+   * Order by which the items should be sorted.
+   */
+  order?: Order<T>[];
+  /**
+   * Groups items by specified fields.
+   */
+  group?: Group<T>[];
+};

package/lib/types/QueryUpdate.ts

@@ -0,0 +1,19 @@
+import type { Filter } from "./Filter";
+
+/**
+ * Query for updating an item.
+ */
+export type QueryUpdate<T extends object> = {
+  method: "update";
+  /**
+   * Partial property values to update.
+   */
+  value: Partial<T>;
+  /**
+   * Filter for finding the item, if it cannot be found based on the `context`.
+   */
+  filter?: Filter<T>;
+  offset?: never;
+  order: never;
+  group?: never;
+};

package/lib/types/QueryUpdateMultiple.ts

@@ -0,0 +1,27 @@
+import type { Filter } from "./Filter";
+import type { Order } from "./Order";
+
+/**
+ * Query for updating multiple items.
+ */
+export type QueryUpdateMultiple<T extends object> = {
+  method: "update";
+  multiple: true;
+  /**
+   * Partial property values to update.
+   */
+  value: Partial<T>[];
+  filter?: Filter<T>;
+  /**
+   * Order by which the items should be sorted.
+   */
+  order?: Order<T>[];
+  /**
+   * Offset of the first matching item to update.
+   */
+  offset?: number;
+  /**
+   * Sets the upper bound of the number of items to update.
+   */
+  limit?: number;
+};

package/lib/types/Result.ts

@@ -0,0 +1,38 @@
+import type { CustomFieldMap } from "./CustomFieldMap";
+import type { InjectCustomFields } from "./InjectCustomFields";
+import type { Item } from "./Item";
+import type { Query } from "./Query";
+
+export type PickFields<T extends object, F extends string | number | symbol> = [
+  F,
+] extends [keyof T]
+  ? { readonly [K in F]: T[K] }
+  : { readonly [K in keyof T]: T[K] };
+
+export type ResultRead<
+  T extends object,
+  Q extends Query<T, C>,
+  C extends CustomFieldMap<T>,
+  U extends InjectCustomFields<T, C> = InjectCustomFields<T, C>,
+> = [C] extends [CustomFieldMap<T>]
+  ? [Q] extends [{ fields: (keyof U)[] }]
+    ? PickFields<U, Item<Q["fields"]>>
+    : U
+  : [Q] extends [{ fields: (keyof T)[] }]
+  ? PickFields<T, Item<Q["fields"]>>
+  : T;
+
+export type Result<
+  T extends object,
+  Q extends Query<T, C>,
+  C extends CustomFieldMap<T>,
+  U extends InjectCustomFields<T, C> = InjectCustomFields<T, C>,
+> = [Q] extends [{ method: "read" }]
+  ? [Q] extends [{ multiple: true }]
+    ? ResultRead<T, Q, C, U>[]
+    : ResultRead<T, Q, C, U>
+  : [Q] extends [{ method: "aggregate" }]
+  ? number
+  : [Q] extends [{ multiple: true }]
+  ? ResultRead<T, Q, C, U>[]
+  : ResultRead<T, Q, C, U>;

package/lib/types/Store.ts

@@ -0,0 +1,7 @@
+// TODO: Move to other library
+export type Store<T = any> = {
+  has(key: string): Promise<boolean>;
+  get(key: string): Promise<T>;
+  set(key: string, value: T): Promise<void>;
+  delete(key: string): Promise<void>;
+};