@wener/common 1.0.3 → 1.0.4

package/src/search/types.d.ts

@@ -1,71 +1,45 @@
 export type Exprs = Expr[];
 export type Expr =
-  | CommentExpr
-  | ParenthesesExpr
-  | KeywordCondition
-  | LogicalCondition
-  | NotCondition
-  | CompareCondition;
+	| CommentExpr
+	| ParenthesesExpr
+	| KeywordCondition
+	| LogicalCondition
+	| NotCondition
+	| CompareCondition;
 
-export type CommentExpr = {
-  type: 'comment';
-  value: string;
-};
+export type CommentExpr = { type: 'comment'; value: string };
 
-export type ParenthesesExpr = {
-  type: 'parentheses';
-  value: Expr[];
-};
+export type ParenthesesExpr = { type: 'parentheses'; value: Expr[] };
 
-export type KeywordCondition = {
-  type: 'keyword';
-  value: string;
-  negative?: boolean;
-  exact?: boolean;
-};
+export type KeywordCondition = { type: 'keyword'; value: string; negative?: boolean; exact?: boolean };
 
-export type LogicalCondition = {
-  type: 'logical';
-  operator: 'and' | 'or';
-  value: Expr[];
-};
+export type LogicalCondition = { type: 'logical'; operator: 'and' | 'or'; value: Expr[] };
 
-export type NotCondition = {
-  type: 'not';
-  value: Expr;
-};
+export type NotCondition = { type: 'not'; value: Expr };
 
 export type CompareCondition = {
-  type: 'compare';
-  field: string;
-  /**
-   * mention value for eq, ne only
-   * range require range value
-   */
-  operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'range' | 'match';
-  negative?: boolean;
-  mention?: boolean;
-  value: Value;
+	type: 'compare';
+	field: string;
+	/**
+	 * mention value for eq, ne only
+	 * range require range value
+	 */
+	operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'range' | 'match';
+	negative?: boolean;
+	mention?: boolean;
+	value: Value;
 };
 
 export type Value = LiteralValue | RangeValue | MentionValue;
 
-export type LiteralValue = {
-  type?: 'literal';
-  format?: 'date' | 'date-time';
-  value: string | number | null;
-};
+export type LiteralValue = { type?: 'literal'; format?: 'date' | 'date-time'; value: string | number | null };
 
-export type MentionValue = {
-  type?: 'literal';
-  format: 'mention';
-  value: string;
-};
+export type MentionValue = { type?: 'literal'; format: 'mention'; value: string };
 
 export type RangeValue = {
-  type: 'range';
-  minimum: LiteralValue | undefined;
-  maximum: LiteralValue | undefined;
-  minimumExclusive: boolean;
-  maximumExclusive: boolean;
+	type: 'range';
+	minimum: LiteralValue | undefined;
+	maximum: LiteralValue | undefined;
+	minimumExclusive: boolean;
+	maximumExclusive: boolean;
 };

package/src/tools/renderJsonSchemaToMarkdownDoc.ts

@@ -1,93 +1,93 @@
 import type { TObject, TSchema } from '@sinclair/typebox';
 
 export function renderJsonSchemaToMarkdownDoc(rootSchema: any) {
-  // markdown
-  const out: string[] = [];
-  const all = new Set();
-  const pending: TSchema[] = [];
+	// markdown
+	const out: string[] = [];
+	const all = new Set();
+	const pending: TSchema[] = [];
 
-  const addObject = (o: TSchema) => {
-    if (all.has(o.$id)) {
-      return;
-    }
-    all.add(o.$id);
-    pending.push(o);
-  };
+	const addObject = (o: TSchema) => {
+		if (all.has(o.$id)) {
+			return;
+		}
+		all.add(o.$id);
+		pending.push(o);
+	};
 
-  const writeObjectProps = (T: TObject, { prefix = '' }: { prefix?: string } = {}) => {
-    if (!T?.properties) {
-      return;
-    }
-    for (const [name, schema] of Object.entries(T.properties)) {
-      let typ = schema.$id || schema.type;
+	const writeObjectProps = (T: TObject, { prefix = '' }: { prefix?: string } = {}) => {
+		if (!T?.properties) {
+			return;
+		}
+		for (const [name, schema] of Object.entries(T.properties)) {
+			let typ = schema.$id || schema.type;
 
-      if (typ === 'array') {
-        typ = `${schema.items.$id || schema.items.type}[]`;
-        if (schema.items.$id) {
-          addObject(schema.items);
-        }
-      } else if (schema.$id) {
-        addObject(schema);
-      }
-      if (!typ) {
-        if ('anyOf' in schema) {
-          typ = 'enum';
-        }
-      }
+			if (typ === 'array') {
+				typ = `${schema.items.$id || schema.items.type}[]`;
+				if (schema.items.$id) {
+					addObject(schema.items);
+				}
+			} else if (schema.$id) {
+				addObject(schema);
+			}
+			if (!typ) {
+				if ('anyOf' in schema) {
+					typ = 'enum';
+				}
+			}
 
-      out.push(`| ${prefix}${name} | ${typ} | ${schema.title || schema.description || ''} |`);
+			out.push(`| ${prefix}${name} | ${typ} | ${schema.title || schema.description || ''} |`);
 
-      if (typ === 'object') {
-        writeObjectProps(schema as TObject, { prefix: `${prefix}${name}.` });
-      } else if (schema.type === 'array') {
-        if (schema.items.type === 'object' && !schema.items.$id) {
-          writeObjectProps(schema.items as TObject, { prefix: `${prefix}${name}[].` });
-        }
-      }
-    }
-  };
-  const writeObject = (T: TObject) => {
-    out.push(`### ${T.title || T.$id}`);
-    out.push(`
+			if (typ === 'object') {
+				writeObjectProps(schema as TObject, { prefix: `${prefix}${name}.` });
+			} else if (schema.type === 'array') {
+				if (schema.items.type === 'object' && !schema.items.$id) {
+					writeObjectProps(schema.items as TObject, { prefix: `${prefix}${name}[].` });
+				}
+			}
+		}
+	};
+	const writeObject = (T: TObject) => {
+		out.push(`### ${T.title || T.$id}`);
+		out.push(`
 | $id | 名字 |
 | --- | --- |
 | ${T.$id || ''} | ${T.title || ''} | 
     `);
-    if (T.description) {
-      out.push('');
-      out.push(`> ${T.description}`);
-      out.push('');
-    }
+		if (T.description) {
+			out.push('');
+			out.push(`> ${T.description}`);
+			out.push('');
+		}
 
-    out.push(`| 名字 | 类型 | 说明 |`);
-    out.push(`| --- | --- | --- |`);
+		out.push(`| 名字 | 类型 | 说明 |`);
+		out.push(`| --- | --- | --- |`);
 
-    writeObjectProps(T);
+		writeObjectProps(T);
 
-    out.push('');
-  };
+		out.push('');
+	};
 
-  writeObject(rootSchema);
+	writeObject(rootSchema);
 
-  for (const schema of pending) {
-    if (schema.type === 'object') {
-      writeObject(schema as TObject);
-    } else if ('anyOf' in schema) {
-      out.push(`### ${schema.$id || schema.title}`);
-      out.push(`
+	for (const schema of pending) {
+		if (schema.type === 'object') {
+			writeObject(schema as TObject);
+		} else if ('anyOf' in schema) {
+			out.push(`### ${schema.$id || schema.title}`);
+			out.push(`
 | $id | 名字 |
 | --- | --- |
 | ${schema.$id || ''} | ${schema.title || ''} | 
     `);
 
-      out.push(`| 值 |  说明 |`);
-      out.push(`| --- | --- |`);
-      for (const item of schema.anyOf) {
-        out.push(`| ${item.const} | ${item.title || item.description || ''} |`);
-      }
-      out.push('');
-    }
-  }
+			out.push(`| 值 |  说明 |`);
+			out.push(`| --- | --- |`);
+			for (const item of schema.anyOf) {
+				out.push(`| ${item.const} | ${item.title || item.description || ''} |`);
+			}
+			out.push('');
+		}
+	}
 
-  return out.join('\n');
+	return out.join('\n');
 }

package/lib/normalizePagination.js

@@ -1,14 +0,0 @@
-export function normalizePagination(page) {
-    let { pageSize = normalizePagination.defaultPageSize, pageNumber = 1, pageIndex = pageNumber - 1, limit, offset } = page;
-    if (normalizePagination.maxPageSize) {
-        pageSize = Math.min(pageSize, normalizePagination.maxPageSize);
-    }
-    return {
-        limit: limit || pageSize,
-        offset: Math.min(0, offset ?? pageIndex * pageSize)
-    };
-}
-normalizePagination.defaultPageSize = 20;
-normalizePagination.maxPageSize = undefined;
-
-//# sourceMappingURL=normalizePagination.js.map

package/lib/normalizePagination.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/normalizePagination.ts"],"sourcesContent":["export function normalizePagination(page: {\n  pageSize?: number;\n  pageIndex?: number;\n  pageNumber?: number;\n  limit?: number;\n  offset?: number;\n}) {\n  let {\n    pageSize = normalizePagination.defaultPageSize,\n    pageNumber = 1,\n    pageIndex = pageNumber - 1,\n    limit,\n    offset,\n  } = page;\n  if (normalizePagination.maxPageSize) {\n    pageSize = Math.min(pageSize, normalizePagination.maxPageSize);\n  }\n  return {\n    limit: limit || pageSize,\n    offset: Math.min(0, offset ?? pageIndex * pageSize),\n  };\n}\n\nnormalizePagination.defaultPageSize = 20;\nnormalizePagination.maxPageSize = undefined as number | undefined;\n"],"names":["normalizePagination","page","pageSize","defaultPageSize","pageNumber","pageIndex","limit","offset","maxPageSize","Math","min","undefined"],"mappings":"AAAA,OAAO,SAASA,oBAAoBC,IAMnC;IACC,IAAI,EACFC,WAAWF,oBAAoBG,eAAe,EAC9CC,aAAa,CAAC,EACdC,YAAYD,aAAa,CAAC,EAC1BE,KAAK,EACLC,MAAM,EACP,GAAGN;IACJ,IAAID,oBAAoBQ,WAAW,EAAE;QACnCN,WAAWO,KAAKC,GAAG,CAACR,UAAUF,oBAAoBQ,WAAW;IAC/D;IACA,OAAO;QACLF,OAAOA,SAASJ;QAChBK,QAAQE,KAAKC,GAAG,CAAC,GAAGH,UAAUF,YAAYH;IAC5C;AACF;AAEAF,oBAAoBG,eAAe,GAAG;AACtCH,oBAAoBQ,WAAW,GAAGG"}

package/lib/parseSort.js

@@ -1,106 +0,0 @@
-import { arrayOfMaybeArray } from "@wener/utils";
-/**
- * parsing order string
- *
- *  e.g.
- *  ```
- *  a desc
- *  +a,-b
- *  a asc nulls last
- *  a desc first
- *  ```
- */ export function parseSort(order) {
-    if (!order) {
-        return [];
-    }
-    return arrayOfMaybeArray(order).flatMap((v)=>{
-        if (!v) return [];
-        if (typeof v === 'object') {
-            // invalid
-            if (!v.field) {
-                return [];
-            }
-            let rule = {
-                field: v.field,
-                order: v.order?.toLowerCase() === 'asc' ? 'asc' : 'desc'
-            };
-            if (v.nulls) {
-                rule.nulls = v.nulls.toLowerCase() === 'last' ? 'last' : 'first';
-            }
-            return rule;
-        }
-        return v.split(',').map((v)=>v.trim()).filter(Boolean).map(_parse);
-    });
-}
-function _parse(v) {
-    // const sp = v.match(/^(?<field>[a-z0-9_]+)(\s+(?<order>asc|desc))?(\s+(?<nulls>nulls\s+(?<nulls_order>last|first)))?$/i);
-    const sp = v.split(/\s+/);
-    let field = '';
-    let order;
-    let nulls;
-    const f = sp.shift();
-    if (f.startsWith('-') || f.startsWith('+')) {
-        // (order = f.slice(1).trim()), f.startsWith('-') ? 'desc' : 'asc';
-        field = f.slice(1).trim();
-        order = f.startsWith('-') ? 'desc' : 'asc';
-    } else {
-        field = f.trim();
-    }
-    while(true){
-        const v = sp.shift()?.trim()?.toLowerCase();
-        if (!v) {
-            break;
-        }
-        switch(v){
-            case 'asc':
-            case 'desc':
-                {
-                    order = v;
-                    break;
-                }
-            case 'nulls':
-                {
-                    nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';
-                    break;
-                }
-            case 'last':
-            case 'first':
-                {
-                    nulls = v;
-                    break;
-                }
-        }
-    }
-    order ||= 'asc';
-    // avoid undefined
-    // NOTE pg default nulls first for desc, last for asc
-    // https://www.postgresql.org/docs/current/queries-order.html
-    if (!nulls) {
-        return {
-            field,
-            order
-        };
-    }
-    return {
-        field,
-        order,
-        nulls
-    };
-}
-export function formatSort(s) {
-    return s.map(({ field, order, nulls })=>{
-        if (field) {
-            let r = field;
-            if (order) {
-                r += ` ${order}`;
-            }
-            if (nulls) {
-                r += ` nulls ${nulls}`;
-            }
-            return r;
-        }
-        return '';
-    }).filter(Boolean);
-}
-
-//# sourceMappingURL=parseSort.js.map

package/lib/parseSort.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parseSort.ts"],"sourcesContent":["import { arrayOfMaybeArray, type MaybeArray } from '@wener/utils';\n\nexport type SortRule = {\n  field: string;\n  order: 'asc' | 'desc';\n  nulls?: 'last' | 'first';\n};\n\n/**\n * parsing order string\n *\n *  e.g.\n *  ```\n *  a desc\n *  +a,-b\n *  a asc nulls last\n *  a desc first\n *  ```\n */\nexport function parseSort(\n  order:\n    | MaybeArray<\n        | {\n            field?: string;\n            order?: string;\n            nulls?: string;\n          }\n        | string\n      >\n    | undefined\n    | null,\n): SortRule[] {\n  if (!order) {\n    return [];\n  }\n\n  return arrayOfMaybeArray(order).flatMap((v): MaybeArray<SortRule> => {\n    if (!v) return [];\n    if (typeof v === 'object') {\n      // invalid\n      if (!v.field) {\n        return [];\n      }\n      let rule: SortRule = {\n        field: v.field,\n        order: v.order?.toLowerCase() === 'asc' ? 'asc' : 'desc',\n      };\n      if (v.nulls) {\n        rule.nulls = v.nulls.toLowerCase() === 'last' ? 'last' : 'first';\n      }\n      return rule;\n    }\n    return v\n      .split(',')\n      .map((v) => v.trim())\n      .filter(Boolean)\n      .map(_parse);\n  });\n}\n\nfunction _parse(v: string) {\n  // const sp = v.match(/^(?<field>[a-z0-9_]+)(\\s+(?<order>asc|desc))?(\\s+(?<nulls>nulls\\s+(?<nulls_order>last|first)))?$/i);\n  const sp = v.split(/\\s+/);\n  let field = '';\n  let order: SortRule['order'];\n  let nulls: SortRule['nulls'];\n\n  const f = sp.shift()!;\n  if (f.startsWith('-') || f.startsWith('+')) {\n    // (order = f.slice(1).trim()), f.startsWith('-') ? 'desc' : 'asc';\n    field = f.slice(1).trim();\n    order = f.startsWith('-') ? 'desc' : 'asc';\n  } else {\n    field = f.trim();\n  }\n\n  while (true) {\n    const v = sp.shift()?.trim()?.toLowerCase();\n    if (!v) {\n      break;\n    }\n\n    switch (v) {\n      case 'asc':\n      case 'desc': {\n        order = v;\n        break;\n      }\n\n      case 'nulls': {\n        nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';\n        break;\n      }\n\n      case 'last':\n      case 'first': {\n        nulls = v;\n        break;\n      }\n    }\n  }\n\n  order ||= 'asc';\n  // avoid undefined\n  // NOTE pg default nulls first for desc, last for asc\n  // https://www.postgresql.org/docs/current/queries-order.html\n  if (!nulls) {\n    return { field, order };\n  }\n  return {\n    field,\n    order,\n    nulls,\n  };\n}\n\nexport function formatSort(s: SortRule[]): string[] {\n  return s\n    .map(({ field, order, nulls }) => {\n      if (field) {\n        let r = field;\n        if (order) {\n          r += ` ${order}`;\n        }\n        if (nulls) {\n          r += ` nulls ${nulls}`;\n        }\n        return r;\n      }\n      return '';\n    })\n    .filter(Boolean);\n}\n"],"names":["arrayOfMaybeArray","parseSort","order","flatMap","v","field","rule","toLowerCase","nulls","split","map","trim","filter","Boolean","_parse","sp","f","shift","startsWith","slice","formatSort","s","r"],"mappings":"AAAA,SAASA,iBAAiB,QAAyB,eAAe;AAQlE;;;;;;;;;;CAUC,GACD,OAAO,SAASC,UACdC,KAUQ;IAER,IAAI,CAACA,OAAO;QACV,OAAO,EAAE;IACX;IAEA,OAAOF,kBAAkBE,OAAOC,OAAO,CAAC,CAACC;QACvC,IAAI,CAACA,GAAG,OAAO,EAAE;QACjB,IAAI,OAAOA,MAAM,UAAU;YACzB,UAAU;YACV,IAAI,CAACA,EAAEC,KAAK,EAAE;gBACZ,OAAO,EAAE;YACX;YACA,IAAIC,OAAiB;gBACnBD,OAAOD,EAAEC,KAAK;gBACdH,OAAOE,EAAEF,KAAK,EAAEK,kBAAkB,QAAQ,QAAQ;YACpD;YACA,IAAIH,EAAEI,KAAK,EAAE;gBACXF,KAAKE,KAAK,GAAGJ,EAAEI,KAAK,CAACD,WAAW,OAAO,SAAS,SAAS;YAC3D;YACA,OAAOD;QACT;QACA,OAAOF,EACJK,KAAK,CAAC,KACNC,GAAG,CAAC,CAACN,IAAMA,EAAEO,IAAI,IACjBC,MAAM,CAACC,SACPH,GAAG,CAACI;IACT;AACF;AAEA,SAASA,OAAOV,CAAS;IACvB,2HAA2H;IAC3H,MAAMW,KAAKX,EAAEK,KAAK,CAAC;IACnB,IAAIJ,QAAQ;IACZ,IAAIH;IACJ,IAAIM;IAEJ,MAAMQ,IAAID,GAAGE,KAAK;IAClB,IAAID,EAAEE,UAAU,CAAC,QAAQF,EAAEE,UAAU,CAAC,MAAM;QAC1C,mEAAmE;QACnEb,QAAQW,EAAEG,KAAK,CAAC,GAAGR,IAAI;QACvBT,QAAQc,EAAEE,UAAU,CAAC,OAAO,SAAS;IACvC,OAAO;QACLb,QAAQW,EAAEL,IAAI;IAChB;IAEA,MAAO,KAAM;QACX,MAAMP,IAAIW,GAAGE,KAAK,IAAIN,QAAQJ;QAC9B,IAAI,CAACH,GAAG;YACN;QACF;QAEA,OAAQA;YACN,KAAK;YACL,KAAK;gBAAQ;oBACXF,QAAQE;oBACR;gBACF;YAEA,KAAK;gBAAS;oBACZI,QAAQO,GAAGE,KAAK,IAAIN,QAAQJ,kBAAkB,SAAS,SAAS;oBAChE;gBACF;YAEA,KAAK;YACL,KAAK;gBAAS;oBACZC,QAAQJ;oBACR;gBACF;QACF;IACF;IAEAF,UAAU;IACV,kBAAkB;IAClB,qDAAqD;IACrD,6DAA6D;IAC7D,IAAI,CAACM,OAAO;QACV,OAAO;YAAEH;YAAOH;QAAM;IACxB;IACA,OAAO;QACLG;QACAH;QACAM;IACF;AACF;AAEA,OAAO,SAASY,WAAWC,CAAa;IACtC,OAAOA,EACJX,GAAG,CAAC,CAAC,EAAEL,KAAK,EAAEH,KAAK,EAAEM,KAAK,EAAE;QAC3B,IAAIH,OAAO;YACT,IAAIiB,IAAIjB;YACR,IAAIH,OAAO;gBACToB,KAAK,CAAC,CAAC,EAAEpB,OAAO;YAClB;YACA,IAAIM,OAAO;gBACTc,KAAK,CAAC,OAAO,EAAEd,OAAO;YACxB;YACA,OAAOc;QACT;QACA,OAAO;IACT,GACCV,MAAM,CAACC;AACZ"}

package/src/normalizePagination.ts

@@ -1,25 +0,0 @@
-export function normalizePagination(page: {
-  pageSize?: number;
-  pageIndex?: number;
-  pageNumber?: number;
-  limit?: number;
-  offset?: number;
-}) {
-  let {
-    pageSize = normalizePagination.defaultPageSize,
-    pageNumber = 1,
-    pageIndex = pageNumber - 1,
-    limit,
-    offset,
-  } = page;
-  if (normalizePagination.maxPageSize) {
-    pageSize = Math.min(pageSize, normalizePagination.maxPageSize);
-  }
-  return {
-    limit: limit || pageSize,
-    offset: Math.min(0, offset ?? pageIndex * pageSize),
-  };
-}
-
-normalizePagination.defaultPageSize = 20;
-normalizePagination.maxPageSize = undefined as number | undefined;

package/src/parseSort.test.ts

@@ -1,42 +0,0 @@
-import { assert, test } from 'vitest';
-import { parseSort } from './parseSort';
-
-test('parseSort', () => {
-  for (const [o, e] of [
-    //
-    ['', []],
-    [[], []],
-    [null, []],
-    // invalid
-    [[{ order: 'asc' }], []],
-    // partial invalid
-    [['a,,', { field: '', order: 'asc' }], [{ field: 'a', order: 'asc' }]],
-    [[',,', { field: 'a', order: 'asc' }], [{ field: 'a', order: 'asc' }]],
-    //
-    ['a', [{ field: 'a', order: 'asc' }]],
-    [['a'], [{ field: 'a', order: 'asc' }]],
-    [[{ field: 'a', order: 'asc' }], [{ field: 'a', order: 'asc' }]],
-    [[{ field: 'a', order: 'asc', nulls: 'last' }], [{ field: 'a', order: 'asc', nulls: 'last' }]],
-    [
-      '-a,+b',
-      [
-        { field: 'a', order: 'desc' },
-        { field: 'b', order: 'asc' },
-      ],
-    ],
-    ['a asc', [{ field: 'a', order: 'asc' }]],
-    ['a desc', [{ field: 'a', order: 'desc' }]],
-    ['a asc  last', [{ field: 'a', order: 'asc', nulls: 'last' }]],
-    ['a asc nulls last', [{ field: 'a', order: 'asc', nulls: 'last' }]],
-    ['a asc nulls first', [{ field: 'a', order: 'asc', nulls: 'first' }]],
-    ['a asc   first', [{ field: 'a', order: 'asc', nulls: 'first' }]],
-    ['a desc nulls last', [{ field: 'a', order: 'desc', nulls: 'last' }]],
-    ['a desc nulls first', [{ field: 'a', order: 'desc', nulls: 'first' }]],
-    ['a nulls first', [{ field: 'a', order: 'asc', nulls: 'first' }]],
-    ['-a nulls first', [{ field: 'a', order: 'desc', nulls: 'first' }]],
-    ['a.b', [{ field: 'a.b', order: 'asc' }]],
-    ['-a asc', [{ field: 'a', order: 'asc' }]], // asc 优先级高
-  ]) {
-    assert.deepEqual(parseSort(o as any), e as any, `parseOrder: ${JSON.stringify(o)}`);
-  }
-});

package/src/parseSort.ts

@@ -1,133 +0,0 @@
-import { arrayOfMaybeArray, type MaybeArray } from '@wener/utils';
-
-export type SortRule = {
-  field: string;
-  order: 'asc' | 'desc';
-  nulls?: 'last' | 'first';
-};
-
-/**
- * parsing order string
- *
- *  e.g.
- *  ```
- *  a desc
- *  +a,-b
- *  a asc nulls last
- *  a desc first
- *  ```
- */
-export function parseSort(
-  order:
-    | MaybeArray<
-        | {
-            field?: string;
-            order?: string;
-            nulls?: string;
-          }
-        | string
-      >
-    | undefined
-    | null,
-): SortRule[] {
-  if (!order) {
-    return [];
-  }
-
-  return arrayOfMaybeArray(order).flatMap((v): MaybeArray<SortRule> => {
-    if (!v) return [];
-    if (typeof v === 'object') {
-      // invalid
-      if (!v.field) {
-        return [];
-      }
-      let rule: SortRule = {
-        field: v.field,
-        order: v.order?.toLowerCase() === 'asc' ? 'asc' : 'desc',
-      };
-      if (v.nulls) {
-        rule.nulls = v.nulls.toLowerCase() === 'last' ? 'last' : 'first';
-      }
-      return rule;
-    }
-    return v
-      .split(',')
-      .map((v) => v.trim())
-      .filter(Boolean)
-      .map(_parse);
-  });
-}
-
-function _parse(v: string) {
-  // const sp = v.match(/^(?<field>[a-z0-9_]+)(\s+(?<order>asc|desc))?(\s+(?<nulls>nulls\s+(?<nulls_order>last|first)))?$/i);
-  const sp = v.split(/\s+/);
-  let field = '';
-  let order: SortRule['order'];
-  let nulls: SortRule['nulls'];
-
-  const f = sp.shift()!;
-  if (f.startsWith('-') || f.startsWith('+')) {
-    // (order = f.slice(1).trim()), f.startsWith('-') ? 'desc' : 'asc';
-    field = f.slice(1).trim();
-    order = f.startsWith('-') ? 'desc' : 'asc';
-  } else {
-    field = f.trim();
-  }
-
-  while (true) {
-    const v = sp.shift()?.trim()?.toLowerCase();
-    if (!v) {
-      break;
-    }
-
-    switch (v) {
-      case 'asc':
-      case 'desc': {
-        order = v;
-        break;
-      }
-
-      case 'nulls': {
-        nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';
-        break;
-      }
-
-      case 'last':
-      case 'first': {
-        nulls = v;
-        break;
-      }
-    }
-  }
-
-  order ||= 'asc';
-  // avoid undefined
-  // NOTE pg default nulls first for desc, last for asc
-  // https://www.postgresql.org/docs/current/queries-order.html
-  if (!nulls) {
-    return { field, order };
-  }
-  return {
-    field,
-    order,
-    nulls,
-  };
-}
-
-export function formatSort(s: SortRule[]): string[] {
-  return s
-    .map(({ field, order, nulls }) => {
-      if (field) {
-        let r = field;
-        if (order) {
-          r += ` ${order}`;
-        }
-        if (nulls) {
-          r += ` nulls ${nulls}`;
-        }
-        return r;
-      }
-      return '';
-    })
-    .filter(Boolean);
-}