@kubun/db-adapter 0.12.0 → 0.13.0

package/lib/postgres.d.ts

@@ -1,5 +1,5 @@
 import type { Expression, Kysely, RawBuilder } from 'kysely';
-import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
+import type { AbstractAdapter, AdapterTypes, ArrayPresenceMode, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
 export type PostgresTypes = {
     Binary: Uint8Array;
     JSON: unknown;
@@ -15,6 +15,10 @@ export declare class AbstractPostgresAdapter<T extends AdapterTypes = PostgresTy
     coerceFilterValue(value: unknown): unknown;
     numericCast(expression: Expression<unknown>): Expression<number>;
     nullOrdering(_expression: Expression<unknown>, _direction: OrderDirection): NullOrderingTerm;
+    containsPredicate(expression: Expression<unknown>, pattern: string): RawBuilder<boolean>;
+    arrayIncludesAllPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayIncludesAnyPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayPresencePredicate(expression: Expression<unknown>, mode: ArrayPresenceMode): RawBuilder<boolean>;
     readAccessPredicate(params: {
         viewerDID: string;
         groupIDs: Array<string>;

package/lib/postgres.js

@@ -41,6 +41,40 @@ export class AbstractPostgresAdapter {
             kind: 'native'
         };
     }
+    containsPredicate(expression, pattern) {
+        return sql`${expression} ILIKE ${pattern} ESCAPE '\\'`;
+    }
+    arrayIncludesAllPredicate(expression, values) {
+        // Native jsonb containment: works for string and numeric elements alike. NULL node
+        // coalesces to an empty array, which is a subset only of another empty set.
+        // Cast via ::text::jsonb, not a direct ::jsonb: postgres.js infers the parameter's
+        // wire type from a trailing ::jsonb cast and re-encodes the JS string as a jsonb
+        // *string scalar* instead of sending it as text for the server to parse, so a
+        // direct ::jsonb cast silently never matches. The ::text hop forces text encoding.
+        return sql`COALESCE(${expression}, '[]'::jsonb) @> ${JSON.stringify(values)}::text::jsonb`;
+    }
+    arrayIncludesAnyPredicate(expression, values) {
+        // Elements, not `?|`, so numeric arrays are covered too (`?|` only matches string keys).
+        return sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(${expression}, '[]'::jsonb)) AS _t WHERE _t IN (${sql.join(values.map((v)=>sql`${v}`))}))`;
+    }
+    arrayPresencePredicate(expression, mode) {
+        // null/nonNull/empty/nonEmpty must see the true NULL, so the node is never coalesced
+        // there — jsonb_array_length(NULL) is NULL, and NULL > 0 is not-true (excludes it).
+        switch(mode){
+            case 'null':
+                return sql`${expression} IS NULL`;
+            case 'nonNull':
+                return sql`${expression} IS NOT NULL`;
+            case 'empty':
+                return sql`jsonb_array_length(${expression}) = 0`;
+            case 'nonEmpty':
+                return sql`jsonb_array_length(${expression}) > 0`;
+            case 'nullOrEmpty':
+                return sql`COALESCE(jsonb_array_length(${expression}), 0) = 0`;
+            default:
+                throw new Error(`Invalid array presence mode: ${mode}`);
+        }
+    }
     readAccessPredicate(params, modelID) {
         const { viewerDID, groupIDs, circleIDs, serverDefault } = params;
         const docRestrictedParts = [

package/lib/sqlite.d.ts

@@ -1,5 +1,5 @@
 import type { Expression, Kysely, RawBuilder } from 'kysely';
-import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
+import type { AbstractAdapter, AdapterTypes, ArrayPresenceMode, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
 export type SQLiteTypes = {
     Binary: Uint8Array;
     JSON: string;
@@ -15,6 +15,10 @@ export declare class AbstractSQLiteAdapter<T extends AdapterTypes = SQLiteTypes>
     coerceFilterValue(value: unknown): unknown;
     numericCast(expression: Expression<unknown>): Expression<number>;
     nullOrdering(expression: Expression<unknown>, direction: OrderDirection): NullOrderingTerm;
+    containsPredicate(expression: Expression<unknown>, pattern: string): RawBuilder<boolean>;
+    arrayIncludesAllPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayIncludesAnyPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayPresencePredicate(expression: Expression<unknown>, mode: ArrayPresenceMode): RawBuilder<boolean>;
     readAccessPredicate(params: {
         viewerDID: string;
         groupIDs: Array<string>;

package/lib/sqlite.js

@@ -45,6 +45,36 @@ export class AbstractSQLiteAdapter {
             expression: sql`CASE WHEN ${expression} IS NULL THEN ${sql.lit(nullRank)} ELSE ${sql.lit(valueRank)} END`
         };
     }
+    containsPredicate(expression, pattern) {
+        // SQLite's LIKE is already ASCII case-insensitive by default.
+        return sql`${expression} LIKE ${pattern} ESCAPE '\\'`;
+    }
+    arrayIncludesAllPredicate(expression, values) {
+        // NULL/absent node -> json_each yields zero rows -> COUNT(DISTINCT value) = 0, never
+        // equal to a positive set size.
+        return sql`(SELECT COUNT(DISTINCT value) FROM json_each(COALESCE(${expression}, '[]')) WHERE value IN (${sql.join(values.map((v)=>sql`${v}`))})) = ${values.length}`;
+    }
+    arrayIncludesAnyPredicate(expression, values) {
+        return sql`EXISTS (SELECT 1 FROM json_each(COALESCE(${expression}, '[]')) WHERE value IN (${sql.join(values.map((v)=>sql`${v}`))}))`;
+    }
+    arrayPresencePredicate(expression, mode) {
+        // null/nonNull/empty/nonEmpty must see the true NULL, so the node is never coalesced
+        // there — json_array_length(NULL) is NULL, and NULL > 0 is not-true (excludes it).
+        switch(mode){
+            case 'null':
+                return sql`${expression} IS NULL`;
+            case 'nonNull':
+                return sql`${expression} IS NOT NULL`;
+            case 'empty':
+                return sql`json_array_length(${expression}) = 0`;
+            case 'nonEmpty':
+                return sql`json_array_length(${expression}) > 0`;
+            case 'nullOrEmpty':
+                return sql`COALESCE(json_array_length(${expression}), 0) = 0`;
+            default:
+                throw new Error(`Invalid array presence mode: ${mode}`);
+        }
+    }
     readAccessPredicate(params, modelID) {
         const { viewerDID, groupIDs, circleIDs, serverDefault } = params;
         const docRestrictedParts = [

package/lib/types.d.ts

@@ -1,5 +1,6 @@
 import type { ColumnDataType, ColumnType, Dialect, Expression, Kysely, RawBuilder } from 'kysely';
 export type OrderDirection = 'asc' | 'desc';
+export type ArrayPresenceMode = 'null' | 'nonNull' | 'empty' | 'nonEmpty' | 'nullOrEmpty';
 export type NullOrderingTerm = {
     kind: 'lead';
     expression: Expression<number>;
@@ -53,6 +54,10 @@ export type AbstractAdapter<T extends AdapterTypes = AdapterTypes> = {
     coerceFilterValue(value: unknown): unknown;
     numericCast(expression: Expression<unknown>): Expression<number>;
     nullOrdering(expression: Expression<unknown>, direction: OrderDirection): NullOrderingTerm;
+    containsPredicate(expression: Expression<unknown>, pattern: string): RawBuilder<boolean>;
+    arrayIncludesAllPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayIncludesAnyPredicate(expression: Expression<unknown>, values: Array<unknown>): RawBuilder<boolean>;
+    arrayPresencePredicate(expression: Expression<unknown>, mode: ArrayPresenceMode): RawBuilder<boolean>;
     readAccessPredicate(params: {
         viewerDID: string;
         groupIDs: Array<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/db-adapter",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,7 +15,10 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "kysely": "^0.29.4"
+    "kysely": "^0.29.5"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",