simplify output types

src/queryBuilders/getItemQueryBuilder.integration.test.ts

@@ -33,12 +33,21 @@ describe("GetItemQueryBuilder", () => {
         dataTimestamp: TEST_DATA[0].dataTimestamp,
       })
       .consistentRead(true)
-      .attributes(["somethingElse", "someBoolean"])
+      .attributes(["userId", "somethingElse", "someBoolean"])
       .execute();
 
+    expectTypeOf(data).toEqualTypeOf<
+      | {
+          userId: string;
+          somethingElse?: number;
+          someBoolean?: boolean;
+        }
+      | undefined
+    >();
+
     expect(data?.somethingElse).toBe(TEST_DATA[0].somethingElse);
     expect(data?.someBoolean).toBe(TEST_DATA[0].someBoolean);
-    expect(Object.keys(data!).length).toBe(2);
+    expect(Object.keys(data!).length).toBe(3);
   });
 
   it("handles selecting nested attributes", async () => {

src/typeHelpers.test-d.ts

@@ -1,6 +1,35 @@
-import { SelectAttributes, type ObjectFullPaths } from "./typeHelpers";
+import { PartitionKey, SortKey } from ".";
+import {
+  OmitKeys,
+  PickPk,
+  PickSk,
+  PickSkRequired,
+  SelectAttributes,
+  StripKeys,
+  type ObjectFullPaths,
+} from "./typeHelpers";
 
 describe("typeHelpers typecheck", () => {
+  it("PK and SK util", () => {
+    interface Table {
+      pk: PartitionKey<string>;
+      sk: SortKey<number>;
+      somethingElse: string;
+    }
+
+    type pk = PickPk<Table>;
+    expectTypeOf<pk>().toEqualTypeOf<{ pk: string }>();
+
+    type sk = PickSk<Table>;
+    expectTypeOf<sk>().toEqualTypeOf<{ sk?: number }>();
+
+    type skr = PickSkRequired<Table>;
+    expectTypeOf<skr>().toEqualTypeOf<{ sk: number }>();
+
+    type noKeys = OmitKeys<Table>;
+    expectTypeOf<noKeys>().toEqualTypeOf<{ somethingElse: string }>();
+  });
+
   it("ObjectFullPaths typecheck", () => {
     type empty = ObjectFullPaths<{}>;
     expectTypeOf<empty>().toEqualTypeOf<never>();

src/typeHelpers.ts

@@ -7,10 +7,9 @@ import type { PartitionKey, SortKey } from "./ddbTypes";
  * @see PartitionKey
  */
 export type PickPk<Table> = {
-  [P in keyof Table as Table[P] extends { _PK: true } ? P : never]: Omit<
-    Table[P],
-    "_PK"
-  >;
+  [P in keyof Table as Table[P] extends { _PK: true }
+    ? P
+    : never]: Table[P] extends PartitionKey<infer U> ? U : never;
 };
 
 /**
@@ -19,10 +18,9 @@ export type PickPk<Table> = {
  * @see SortKey
  */
 export type PickSk<Table> = {
-  [P in keyof Table as Table[P] extends { _SK: true } ? P : never]?: Omit<
-    Table[P],
-    "_SK"
-  >;
+  [P in keyof Table as Table[P] extends { _SK: true }
+    ? P
+    : never]?: Table[P] extends SortKey<infer U> ? U : never;
 };
 
 export type PickAllKeys<Table> = PickPk<Table> & PickSk<Table>;
@@ -39,10 +37,9 @@ export type PickNonKeys<Table> = {
  * @see SortKey
  */
 export type PickSkRequired<Table> = {
-  [P in keyof Table as Table[P] extends { _SK: true } ? P : never]: Omit<
-    Table[P],
-    "_SK"
-  >;
+  [P in keyof Table as Table[P] extends { _SK: true }
+    ? P
+    : never]: Table[P] extends SortKey<infer U> ? U : never;
 };
 
 /**
@@ -57,6 +54,19 @@ export type StripKeys<T> = T extends { _PK: true }
   ? Omit<T, "_SK">
   : T;
 
+/**
+ * Returns object without keys
+ * @see PartitionKey
+ * @see SortKey
+ */
+export type OmitKeys<Table> = {
+  [P in keyof Table as Table[P] extends { _SK: true }
+    ? never
+    : Table[P] extends { _PK: true }
+    ? never
+    : P]: Table[P];
+};
+
 /**
  * Returns a subset of a table's properties.
  */
@@ -89,7 +99,7 @@ type RecursiveSelectAttributes<Table, Properties> = Properties extends [
 
 export type SelectAttributes<
   Table,
-  Attributes extends ReadonlyArray<string>
+  Attributes extends Array<string>
 > = IntersectionToSingleObject<
   UnionToIntersection<
     RecursiveSelectAttributes<Table, ParsePath<Attributes[number]>>
@@ -119,8 +129,11 @@ export type DeepPartial<T> = {
     : T[P];
 };
 
-export type ExecuteOutput<O> = StripKeys<
-  PickPk<O> & PickSkRequired<O> & DeepPartial<O>
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type Simplify<T> = DrainOuterGeneric<{ [K in keyof T]: T[K] } & {}>;
+
+export type ExecuteOutput<O> = Simplify<
+  PickPk<O> & PickSkRequired<O> & DeepPartial<OmitKeys<O>>
 >;
 
 type IntersectionToSingleObject<T> = T extends infer U