@kubun/db-adapter 0.12.0 → 0.13.1

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

@@ -1,4 +1,12 @@
 import { sql } from 'kysely';
+const SEARCH_FIELD_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSearchFieldNames(fields) {
+    for (const field of fields){
+        if (!SEARCH_FIELD_NAME.test(field)) {
+            throw new Error(`invalid search field name: ${JSON.stringify(field)}`);
+        }
+    }
+}
 export class AbstractSQLiteAdapter {
     functions = {
         now: sql`(unixepoch())`
@@ -45,6 +53,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 = [
@@ -91,29 +129,31 @@ export class AbstractSQLiteAdapter {
     )`;
     }
     async createSearchIndex(db, config) {
+        assertSearchFieldNames(config.fields);
         const tableName = `fts_${config.modelID}`;
         const columns = [
-            'document_id UNINDEXED',
-            ...config.fields
-        ].join(', ');
-        await sql`CREATE VIRTUAL TABLE IF NOT EXISTS ${sql.ref(tableName)} USING fts5(${sql.raw(columns)})`.execute(db);
+            sql`${sql.ref('document_id')} UNINDEXED`,
+            ...config.fields.map((f)=>sql.ref(f))
+        ];
+        await sql`CREATE VIRTUAL TABLE IF NOT EXISTS ${sql.ref(tableName)} USING fts5(${sql.join(columns)})`.execute(db);
     }
     async dropSearchIndex(db, modelID) {
         const tableName = `fts_${modelID}`;
         await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(db);
     }
     async updateSearchEntry(db, modelID, documentID, fields, fieldNames) {
+        assertSearchFieldNames(fieldNames);
         const tableName = `fts_${modelID}`;
         await sql`DELETE FROM ${sql.ref(tableName)} WHERE document_id = ${documentID}`.execute(db);
         const columns = [
-            'document_id',
-            ...fieldNames
-        ].join(', ');
+            sql.ref('document_id'),
+            ...fieldNames.map((f)=>sql.ref(f))
+        ];
         const values = [
             documentID,
             ...fieldNames.map((f)=>fields[f] ?? '')
-        ].map((v)=>sql.lit(v));
-        await sql`INSERT INTO ${sql.ref(tableName)} (${sql.raw(columns)}) VALUES (${sql.join(values)})`.execute(db);
+        ];
+        await sql`INSERT INTO ${sql.ref(tableName)} (${sql.join(columns)}) VALUES (${sql.join(values.map((v)=>sql`${v}`))})`.execute(db);
     }
     async removeSearchEntry(db, modelID, documentID) {
         const tableName = `fts_${modelID}`;

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.1",
   "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",