quetch 0.31.0 → 0.32.0

package/lib/types/IntersectUnion.ts

@@ -1,3 +1,6 @@
+/**
+ * Converts a union type to an intersection type.
+ */
 export type IntersectUnion<T> = (
   T extends any ? (_: T) => void : never
 ) extends (_: infer U) => void

package/lib/types/Prettify.ts

@@ -0,0 +1,8 @@
+/**
+ * Prettifies a type by recursively removing any intersections or unions.
+ */
+export type Prettify<T> = T extends (...args: any[]) => any
+  ? T
+  : T extends readonly any[]
+    ? T
+    : { [K in keyof T]: Prettify<T[K]> };

package/lib/types/QueryRead.ts

@@ -1,4 +1,5 @@
 import type { Context } from "./Context";
+import type { Field } from "./Field";
 import type { Filter } from "./Filter";
 import type { Order } from "./Order";
 import type { Parameters } from "./Parameters";
@@ -23,7 +24,7 @@ export type QueryRead<T> = {
   /**
    * Item fields to pick. If omitted, all fields are picked.
    */
-  fields?: readonly (keyof T)[];
+  fields?: readonly Field<T>[];
   /**
    * Filter for finding the item, if it cannot be found based on the `context`.
    */

package/lib/types/QueryReadMultiple.ts

@@ -1,4 +1,5 @@
 import type { Context } from "./Context";
+import type { Field } from "./Field";
 import type { Filter } from "./Filter";
 import type { Group } from "./Group";
 import type { Order } from "./Order";
@@ -26,7 +27,7 @@ export type QueryReadMultiple<T> = {
   /**
    * Item fields to pick. If omitted, all fields are picked.
    */
-  fields?: readonly (keyof T)[];
+  fields?: readonly Field<T>[];
   /**
    * Filter for finding the items.
    */

package/lib/types/Result.ts

@@ -1,28 +1,70 @@
-import type { Item } from "./Item";
+/* eslint-disable line-comment-position */
+import type { Field } from "./Field";
+import type { IntersectUnion } from "./IntersectUnion";
+import type { Prettify } from "./Prettify";
+import type { Primitive } from "./Primitive";
 import type { Query } from "./Query";
+import type { QueryRead } from "./QueryRead";
+import type { QueryReadMultiple } from "./QueryReadMultiple";
 
 /**
  * Picks fields `F` from object `T`.
  */
-export type PickFields<T, F extends string | number | symbol> = [F] extends [
-  keyof T,
-]
-  ? { readonly [K in F]: T[K] }
-  : { readonly [K in keyof T]: T[K] };
+type PickFields<T, F extends readonly Field<T>[]> = [unknown] extends [T]
+  ? T
+  : T extends Primitive
+    ? T
+    : [F] extends [readonly [infer J, ...infer R]]
+      ? Merge<
+          | // J is a single key
+          ([J] extends [keyof T]
+              ? PickField<T, J, T[J]>
+              : // J is a path
+                [J] extends [readonly [infer K, ...infer S]]
+                ? [K] extends [keyof T]
+                  ? PickField<
+                      T,
+                      K,
+                      PickFields<
+                        T[K],
+                        S extends readonly Field<T[K]>[] ? S : never
+                      >
+                    >
+                  : never
+                : never)
+          | (R extends readonly never[]
+              ? never
+              : R extends readonly Field<T>[]
+                ? PickFields<T, R>
+                : never)
+        >
+      : never;
 
-export type ResultRead<T, Q extends Query<T>> = [Q] extends [
-  // FIXME: `keyof T` should be `Field<T>`
-  { fields: (keyof T)[] },
-]
-  ? PickFields<T, Item<Q["fields"]>>
-  : T;
+type Merge<T> = Prettify<IntersectUnion<T>>;
 
-export type Result<T, Q extends Query<T>> = [Q] extends [{ method: "read" }]
-  ? [Q] extends [{ multiple: true }]
-    ? readonly ResultRead<T, Q>[]
-    : ResultRead<T, Q>
-  : [Q] extends [{ method: "aggregate" }]
-    ? number
-    : [Q] extends [{ multiple: true }]
-      ? readonly ResultRead<T, Q>[]
-      : ResultRead<T, Q>;
+/**
+ * Picks a field `K` from object `T` and returns an object with the field `K` and the value `V`.
+ */
+type PickField<T, K extends keyof T, V> = {
+  [P in keyof Pick<T, K>]: V;
+};
+
+/**
+ * Result of a read query.
+ */
+type ResultRead<T, Q extends Query<T>> = [unknown] extends [T]
+  ? T
+  : [Q] extends [{ fields: readonly Field<T>[] }]
+    ? PickFields<T, Q["fields"]>
+    : T;
+
+/**
+ * Result of a read and aggregate query.
+ */
+export type Result<T, Q extends Query<T>> = [Q] extends [QueryReadMultiple<T>]
+  ? readonly ResultRead<T, Q>[]
+  : [Q] extends [QueryRead<T>]
+    ? ResultRead<T, Q>
+    : [Q] extends [{ method: "aggregate" }]
+      ? number
+      : never;

package/lib/types.ts

@@ -48,6 +48,7 @@ export type { OrderNormalized } from "./types/OrderNormalized";
 export type { Parameters } from "./types/Parameters";
 export type { Path } from "./types/Path";
 export type { PathFiltered } from "./types/PathFiltered";
+export type { Prettify } from "./types/Prettify";
 export type { Primitive } from "./types/Primitive";
 export type { PrimitiveObject } from "./types/PrimitiveObject";
 export type { Query } from "./types/Query";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quetch",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "type": "module",
   "main": "./dist/main.js",
   "exports": {
@@ -39,7 +39,9 @@
     "lint": "npm run lint:ts",
     "lint:fix": "npm run lint:ts:fix",
     "lint:ts": "eslint . && tsc --project tsconfig.package.json --noEmit",
-    "lint:types:trace": "tsc --project tsconfig.package.json --noEmit --generateTrace ./trace",
+    "lint:types": "NODE_OPTIONS=--max-old-space-size=8192 tsc --project tsconfig.package.json --noEmit",
+    "lint:types:trace": "NODE_OPTIONS=--max-old-space-size=8192 tsc --project tsconfig.package.json --noEmit --generateTrace ./trace",
+    "lint:types:trace:analyze": "npx analyze-trace trace",
     "lint:ts:fix": "eslint --fix .",
     "release:init": "npm publish --access=public",
     "release:patch": "npm version patch && git push origin --follow-tags && npm publish",