@kubun/db-adapter 0.11.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 = [
@@ -72,6 +106,7 @@ export class AbstractPostgresAdapter {
       OR ((data -> 'accessPermissions' -> 'read' ->> 'level') IS NULL AND EXISTS (
         SELECT 1 FROM kubun_graph_user_model_access_defaults AS _mad
         WHERE _mad.owner_did = owner AND _mad.model_id = ${modelID} AND _mad.permission_type = 'read'
+        AND (_mad.removed IS NULL OR _mad.removed = 0)
         AND (
           _mad.access_level = 'anyone'
           OR (_mad.access_level = 'only_owner' AND owner = ${viewerDID})
@@ -81,6 +116,7 @@ export class AbstractPostgresAdapter {
       OR ((data -> 'accessPermissions' -> 'read' ->> 'level') IS NULL AND NOT EXISTS (
         SELECT 1 FROM kubun_graph_user_model_access_defaults AS _mad2
         WHERE _mad2.owner_did = owner AND _mad2.model_id = ${modelID} AND _mad2.permission_type = 'read'
+        AND (_mad2.removed IS NULL OR _mad2.removed = 0)
       ) AND (${serverDefaultCond}))
     )`;
     }

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 = [
@@ -76,6 +106,7 @@ export class AbstractSQLiteAdapter {
       OR (json_extract(data, '$.accessPermissions.read.level') IS NULL AND EXISTS (
         SELECT 1 FROM kubun_graph_user_model_access_defaults AS _mad
         WHERE _mad.owner_did = owner AND _mad.model_id = ${modelID} AND _mad.permission_type = 'read'
+        AND (_mad.removed IS NULL OR _mad.removed = 0)
         AND (
           _mad.access_level = 'anyone'
           OR (_mad.access_level = 'only_owner' AND owner = ${viewerDID})
@@ -85,6 +116,7 @@ export class AbstractSQLiteAdapter {
       OR (json_extract(data, '$.accessPermissions.read.level') IS NULL AND NOT EXISTS (
         SELECT 1 FROM kubun_graph_user_model_access_defaults AS _mad2
         WHERE _mad2.owner_did = owner AND _mad2.model_id = ${modelID} AND _mad2.permission_type = 'read'
+        AND (_mad2.removed IS NULL OR _mad2.removed = 0)
       ) AND (${serverDefaultCond}))
     )`;
     }

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,30 +1,33 @@
 {
   "name": "@kubun/db-adapter",
-  "version": "0.11.0",
-  "license": "see LICENSE.md",
+  "version": "0.13.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "kysely": "^0.29.2"
+    "kysely": "^0.29.5"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
     "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }