zitejs 0.9.109 → 0.9.110

package/dist/cjs/runtime/filterConditionTypes.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/runtime/filterConditionTypes.test-d.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+(0, vitest_1.describe)("FilterCondition in/notIn", () => {
+    // The idiom that regressed. `.filter(Boolean)` does not narrow in TypeScript,
+    // so this is `(string | undefined)[]` — compiling at all is the assertion.
+    (0, vitest_1.it)("accepts .map(…).filter(Boolean) over a nullable column", () => {
+        const keys = routes.map((r) => r.compositeRouteKey).filter(Boolean);
+        (0, vitest_1.expectTypeOf)(keys).toEqualTypeOf();
+        (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+        (0, vitest_1.expectTypeOf)().toMatchTypeOf();
+    });
+    // One array of a union, not a union of arrays.
+    (0, vitest_1.it)("collapses a nullable column to a single array type", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    // The unwrapping that the conditional exists for: an array-valued column is
+    // filtered by its ELEMENT type, not by arrays of arrays.
+    (0, vitest_1.it)("still unwraps an array-valued column to its element type", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+    (0, vitest_1.it)("leaves a plain scalar column alone", () => {
+        (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    });
+});
+(0, vitest_1.describe)("RecordFilters", () => {
+    // Through the keyed wrapper, which is how app code actually reaches it.
+    (0, vitest_1.it)("accepts the idiom on a nullable key", () => {
+        const filters = {
+            compositeRouteKey: {
+                in: routes.map((r) => r.compositeRouteKey).filter(Boolean),
+            },
+        };
+        (0, vitest_1.expectTypeOf)(filters).toMatchTypeOf();
+    });
+    (0, vitest_1.it)("accepts an element-typed `in` on an array column", () => {
+        const filters = { tags: { in: ["urgent"] } };
+        (0, vitest_1.expectTypeOf)(filters).toMatchTypeOf();
+    });
+});

package/dist/cjs/runtime/index.d.ts

@@ -8,6 +8,11 @@
  * the operands buys little while breaking real migrated code: dates are ISO
  * strings here but 1.0 accepted `number | Date` on every comparison, and
  * `contains` was `any`.
+ *
+ * On `in`/`notIn` the `[]` sits OUTSIDE the conditional. A naked `V`
+ * distributes, so a nullable column produced `string[] | undefined[]` — two
+ * separate array types, neither of which accepts the `(string | undefined)[]`
+ * that `.map(…).filter(Boolean)` yields.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
@@ -15,9 +20,9 @@ export type FilterCondition<V> = {
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** An empty array matches NOTHING — the SDK's filters convert to the nested format, where `in: []` is "is one of nothing". */
-    in?: V extends Array<infer E> ? E[] : V[];
+    in?: (V extends Array<infer E> ? E : V)[];
     /** An empty array applies no filter at all — "is not one of nothing" is always true. */
-    notIn?: V extends Array<infer E> ? E[] : V[];
+    notIn?: (V extends Array<infer E> ? E : V)[];
     lt?: V | number | Date;
     lte?: V | number | Date;
     gt?: V | number | Date;

package/dist/esm/runtime/filterConditionTypes.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/runtime/filterConditionTypes.test-d.js

@@ -0,0 +1,38 @@
+import { describe, it, expectTypeOf } from "vitest";
+describe("FilterCondition in/notIn", () => {
+    // The idiom that regressed. `.filter(Boolean)` does not narrow in TypeScript,
+    // so this is `(string | undefined)[]` — compiling at all is the assertion.
+    it("accepts .map(…).filter(Boolean) over a nullable column", () => {
+        const keys = routes.map((r) => r.compositeRouteKey).filter(Boolean);
+        expectTypeOf(keys).toEqualTypeOf();
+        expectTypeOf().toMatchTypeOf();
+        expectTypeOf().toMatchTypeOf();
+    });
+    // One array of a union, not a union of arrays.
+    it("collapses a nullable column to a single array type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    // The unwrapping that the conditional exists for: an array-valued column is
+    // filtered by its ELEMENT type, not by arrays of arrays.
+    it("still unwraps an array-valued column to its element type", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+    it("leaves a plain scalar column alone", () => {
+        expectTypeOf().toEqualTypeOf();
+    });
+});
+describe("RecordFilters", () => {
+    // Through the keyed wrapper, which is how app code actually reaches it.
+    it("accepts the idiom on a nullable key", () => {
+        const filters = {
+            compositeRouteKey: {
+                in: routes.map((r) => r.compositeRouteKey).filter(Boolean),
+            },
+        };
+        expectTypeOf(filters).toMatchTypeOf();
+    });
+    it("accepts an element-typed `in` on an array column", () => {
+        const filters = { tags: { in: ["urgent"] } };
+        expectTypeOf(filters).toMatchTypeOf();
+    });
+});

package/dist/esm/runtime/index.d.ts

@@ -8,6 +8,11 @@
  * the operands buys little while breaking real migrated code: dates are ISO
  * strings here but 1.0 accepted `number | Date` on every comparison, and
  * `contains` was `any`.
+ *
+ * On `in`/`notIn` the `[]` sits OUTSIDE the conditional. A naked `V`
+ * distributes, so a nullable column produced `string[] | undefined[]` — two
+ * separate array types, neither of which accepts the `(string | undefined)[]`
+ * that `.map(…).filter(Boolean)` yields.
  */
 export type FilterCondition<V> = {
     /** Substring match (text fields) or "has any of these" (linked records). */
@@ -15,9 +20,9 @@ export type FilterCondition<V> = {
     /** Not equal, or — against `null` — "is set". */
     not?: V | null;
     /** An empty array matches NOTHING — the SDK's filters convert to the nested format, where `in: []` is "is one of nothing". */
-    in?: V extends Array<infer E> ? E[] : V[];
+    in?: (V extends Array<infer E> ? E : V)[];
     /** An empty array applies no filter at all — "is not one of nothing" is always true. */
-    notIn?: V extends Array<infer E> ? E[] : V[];
+    notIn?: (V extends Array<infer E> ? E : V)[];
     lt?: V | number | Date;
     lte?: V | number | Date;
     gt?: V | number | Date;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.109",
+  "version": "0.9.110",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",