akanjs 3.0.0-beta.22 → 3.0.0-beta.23

package/fetch/client/wsClient.ts

@@ -107,7 +107,12 @@ export class WsClient {
   #connect() {
     if (this.#destroyed) return;
 
-    this.#ws = new WebSocket(this.url);
+    try {
+      this.#ws = new WebSocket(this.url);
+    } catch (error) {
+      this.logger.error(`Cannot open a WebSocket to ${this.url}: ${error instanceof Error ? error.message : error}`);
+      return;
+    }
     this.#ws.binaryType = "arraybuffer";
     this.#ws.onopen = (e) => {
       this.#reconnectAttempts = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-beta.22",
+  "version": "3.0.0-beta.23",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/resolver/signal.resolver.ts

@@ -5,6 +5,7 @@ import {
   type Cls,
   ENDPOINT_META,
   FIELD_META,
+  Float,
   getEnv,
   ID,
   INTERNAL_META,
@@ -14,7 +15,7 @@ import {
   SLICE_META,
 } from "akanjs/base";
 import { capitalize, cookieHeaderHasAuthToken, Logger } from "akanjs/common";
-import { deserialize, resolvePageLimit, resolvePageSkip, serialize } from "akanjs/constant";
+import { type ConstantField, deserialize, resolvePageLimit, resolvePageSkip, serialize } from "akanjs/constant";
 import { baseDocumentColumns, documentQueryHelper, getFilterSortByKey, type QueryFieldMap } from "akanjs/document";
 import {
   type AkanJob,
@@ -475,9 +476,11 @@ export class SignalResolver {
     }) {}
     return SliceEndpoint;
   }
-  
+
+  static readonly #clientOrderableTypes = new Set<unknown>([Int, Float, String, ID, Boolean, Date]);
   static #assertLiveSort(refName: string, key: string, sliceInfo: SliceInfo) {
-    const lightFields = (sliceInfo.light as unknown as { [FIELD_META]?: Record<string, unknown> })[FIELD_META] ?? {};
+    const lightFields =
+      (sliceInfo.light as unknown as { [FIELD_META]?: Record<string, ConstantField> })[FIELD_META] ?? {};
     for (const sortKey of sliceInfo.liveOption?.sort ?? []) {
       const sort = getFilterSortByKey(sliceInfo.filter, sortKey);
       if (!sort)
@@ -489,9 +492,12 @@ export class SignalResolver {
             `Live slice "${refName}.${key}" declares sort "${sortKey}" on "${path}", which is not in ` +
               `Light${capitalize(refName)}. A subscriber cannot order by a field it never receives.`,
           );
+        const { modelRef, isArray, isMap } = lightFields[path].getProps();
+        if (!isArray && !isMap && SignalResolver.#clientOrderableTypes.has(modelRef)) continue;
         SignalResolver.logger.warn(
-          `Live slice "${refName}.${key}" sorts by "${path}", which is stored inside the document rather than in a ` +
-            `column. SQLite and Postgres order those differently, so a client placing a row may disagree with the server.`,
+          `Live slice "${refName}.${key}" sorts "${sortKey}" by "${path}", which is not an Int, Float, String, ID, ` +
+            `Boolean or Date field, so a client placing a new row may disagree with the server. Sort by one of ` +
+            `those, or leave "${sortKey}" out of .live({ sort }) so the list refetches when a row arrives.`,
         );
       }
     }

package/service/predefinedAdaptor/sql/QueryCompiler.ts

@@ -37,9 +37,9 @@ export class QueryCompiler {
   }
 
   orderBy(sort: Record<string, 1 | -1> = { createdAt: -1 }) {
-    return Object.entries(sort)
-      .map(([path, direction]) => this.dialect.orderTerm(this.fieldExpr(path), direction))
-      .join(", ");
+    const terms = Object.entries(sort);
+    if (!terms.some(([path]) => path === "id")) terms.push(["id", terms.at(-1)?.[1] ?? -1]);
+    return terms.map(([path, direction]) => this.dialect.orderTerm(this.fieldExpr(path), direction)).join(", ");
   }
 
   fieldExpr(path: string) {

package/store/liveInsert.ts

@@ -30,31 +30,53 @@ export const livePlacementIndex = ({
   const sort = sorts?.[sortKey];
   if (!sort || !Object.keys(sort).length) return null;
   const paths = Object.entries(sort);
-  if (paths.some(([path]) => comparableOf(row[path]) === null)) return null;
-  const index = list.findIndex((item) => compareRows(row, item, paths) < 0);
+  if (paths.some(([path]) => comparableOf(row[path]) === undefined)) return null;
+  let orderable = true;
+  const index = list.findIndex((item) => {
+    const order = compareRows(row, item, paths);
+    orderable = order !== null;
+    return order === null || order < 0;
+  });
+  if (!orderable) return null;
   if (index !== -1) return index;
   
   if (cumulative) return hasMore ? null : list.length;
   return list.length < limit ? list.length : null;
 };
 
-const compareRows = (left: LiveSortableRow, right: LiveSortableRow, paths: [string, 1 | -1][]): number => {
+const compareRows = (left: LiveSortableRow, right: LiveSortableRow, paths: [string, 1 | -1][]): number | null => {
   for (const [path, direction] of paths) {
-    const a = comparableOf(left[path]);
-    const b = comparableOf(right[path]);
-    if (a === null || b === null) continue;
-    if (a === b) continue;
-    return (a < b ? -1 : 1) * direction;
+    const order = compareValues(comparableOf(left[path]), comparableOf(right[path]));
+    if (order !== 0) return order === null ? null : order * direction;
   }
-  return 0;
+  const order = compareValues(comparableOf(left.id), comparableOf(right.id));
+  return order === null ? null : order * (paths.at(-1)?.[1] ?? -1);
 };
 
-const comparableOf = (value: unknown): number | string | null => {
-  if (value === null || value === undefined) return null;
+const compareValues = (a: Comparable | undefined, b: Comparable | undefined): number | null => {
+  if (a === undefined || b === undefined) return null;
+  if (a === b) return 0;
+  if (a === null) return -1;
+  if (b === null) return 1;
+  if (typeof a === "string" && typeof b === "string") return compareText(a, b);
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  return null;
+};
+
+const compareText = (a: string, b: string) => {
+  let idx = 0;
+  while (idx < a.length && idx < b.length && a[idx] === b[idx]) idx += 1;
+  return (a.codePointAt(idx) ?? -1) < (b.codePointAt(idx) ?? -1) ? -1 : 1;
+};
+
+type Comparable = number | string | null;
+
+const comparableOf = (value: unknown): Comparable | undefined => {
+  if (value === null) return null;
   if (typeof value === "number" || typeof value === "string") return value;
   if (typeof value === "boolean") return value ? 1 : 0;
   if (value instanceof Date) return value.getTime();
-  const valued: unknown = (value as { valueOf?: () => unknown }).valueOf?.();
+  const valued: unknown = (value as { valueOf?: () => unknown } | undefined)?.valueOf?.();
   if (typeof valued === "number" || typeof valued === "string") return valued;
-  return null;
+  return undefined;
 };