Improve type for sortFields

Author: tjenkinson

rollup.config.mjs

@@ -28,8 +28,8 @@ function replaceCryptoImportWithRequire() {
         return updated;
       }
     },
-    buildEnd() {
-      if (!found) {
+    buildEnd(error) {
+      if (!error && !found) {
         throw new Error('Crypto import not found');
       }
     },

src/cursor.ts

@@ -146,7 +146,7 @@ export function buildCursor<TNode extends Record<string, unknown>>({
 }: {
   queryName: string;
   node: TNode;
-  sortFields: readonly FieldWithOrder[];
+  sortFields: readonly FieldWithOrder<TNode>[];
 }): Cursor {
   const fields: Cursor['fields'] = {};
 

src/field-name.ts

@@ -1,16 +1,16 @@
-import { FieldName as FieldNameZod } from './zod-models/field-name';
-import { FieldNameWithAlias as FieldNameWithAliasZod } from './zod-models/field-name-with-alias';
+import { FieldName as FieldNameType } from './zod-models/field-name';
+import { FieldNameWithAlias as FieldNameWithAliasType } from './zod-models/field-name-with-alias';
 
 const regex = /[^.]*$/;
 
-export type ParsedFieldName = {
-  alias: string;
+export type ParsedFieldName<TNode extends Record<string, unknown>> = {
+  alias: string & keyof TNode;
   name: string;
 };
 
-export function parseFieldName(
-  fieldName: FieldNameZod | FieldNameWithAliasZod,
-): ParsedFieldName {
+export function parseFieldName<TNode extends Record<string, unknown>>(
+  fieldName: FieldNameType<TNode> | FieldNameWithAliasType<TNode>,
+): ParsedFieldName<TNode> {
   const name = typeof fieldName === 'string' ? fieldName : fieldName.name;
   const alias =
     typeof fieldName === 'string'

src/index.ts

@@ -2,7 +2,12 @@
 export * from './sql-cursor-pagination';
 export { decryptCursor, rawCursor, RawCursor } from './cursor';
 export { buildCursorSecret } from './cursor-secret';
-export type { Order } from './zod-models/order';
 export { Asc, Desc } from './zod-models/order';
 export type * from './query-builder';
 export * from './errors';
+export type { Cursor } from './zod-models/cursor';
+export type { FieldNameWithAlias } from './zod-models/field-name-with-alias';
+export type { FieldName } from './zod-models/field-name';
+export type { FieldValue } from './zod-models/field-value';
+export type { FieldWithOrder } from './zod-models/field-with-order';
+export type { Order } from './zod-models/order';

src/sql-cursor-pagination.ts

@@ -93,7 +93,7 @@ type _WithPaginationInputSetup<
    * There must be at least one entry and you must include an entry that maps to a unique key,
    * otherwise it's possible for there to be cursor collisions, which will result  in an exception.
    */
-  sortFields: readonly FieldWithOrder[];
+  sortFields: readonly FieldWithOrder<TNode>[];
   /**
    * A name for this query.
    *

src/subtype.ts

@@ -0,0 +1,3 @@
+/* c8 ignore start */
+// eslint-disable-next-line no-use-before-define
+export type Subtype<Sub extends Super, Super> = Sub;

src/zod-models/field-name-with-alias.ts

@@ -1,7 +1,14 @@
 import { z } from 'zod';
+import { Subtype } from '../subtype';
 import { FieldName } from './field-name';
 
 export const FieldNameWithAlias = z
   .object({ alias: z.string().min(1), name: FieldName })
   .readonly();
-export type FieldNameWithAlias = z.TypeOf<typeof FieldNameWithAlias>;
+export type FieldNameWithAlias<TNode extends Record<string, unknown>> = Subtype<
+  {
+    readonly alias: string & keyof TNode;
+    readonly name: string;
+  },
+  z.TypeOf<typeof FieldNameWithAlias>
+>;

src/zod-models/field-name.ts

@@ -1,8 +1,19 @@
 import { z } from 'zod';
+import { Subtype } from '../subtype';
 
 const fieldRegex = /^[a-zA-Z0-9_]*(\.[a-zA-Z0-9_]*)*$/;
+
+export type FullyQualifiedName<TName extends string> = `${string}.${TName}`;
+export type MaybeFullyQualifiedName<TName extends string> =
+  | TName
+  | FullyQualifiedName<TName>;
+
 export const FieldName = z
   .string()
   .min(1)
   .regex(fieldRegex, 'Invalid field name');
-export type FieldName = z.TypeOf<typeof FieldName>;
+
+export type FieldName<TNode> = Subtype<
+  MaybeFullyQualifiedName<string & keyof TNode>,
+  z.TypeOf<typeof FieldName>
+>;

src/zod-models/field-with-order.ts

@@ -1,4 +1,5 @@
 import z from 'zod';
+import { Subtype } from '../subtype';
 import { FieldName } from './field-name';
 import { FieldNameWithAlias } from './field-name-with-alias';
 import { Order } from './order';
@@ -9,4 +10,11 @@ export const FieldWithOrder = z
     order: Order,
   })
   .readonly();
-export type FieldWithOrder = z.TypeOf<typeof FieldWithOrder>;
+
+export type FieldWithOrder<TNode extends Record<string, unknown>> = Subtype<
+  {
+    readonly field: FieldName<TNode> | FieldNameWithAlias<TNode>;
+    readonly order: Order;
+  },
+  z.TypeOf<typeof FieldWithOrder>
+>;