@kubun/store-graph 0.12.0 → 0.13.0

package/lib/api.js

@@ -451,7 +451,7 @@ export function createGraphStore(db, adapter) {
                 query = query.where('owner', 'in', effectiveOwners);
             }
             if (filter != null) {
-                query = query.where((eb)=>applyDocumentFilter(eb, filter, [], coerce));
+                query = query.where((eb)=>applyDocumentFilter(eb, filter, adapter, [], coerce));
             }
             for (const model of rest){
                 query = query.unionAll((eb)=>{
@@ -463,7 +463,7 @@ export function createGraphStore(db, adapter) {
                         q = q.where('owner', 'in', effectiveOwners);
                     }
                     if (filter != null) {
-                        q = q.where((eb)=>applyDocumentFilter(eb, filter, [], coerce));
+                        q = q.where((eb)=>applyDocumentFilter(eb, filter, adapter, [], coerce));
                     }
                     return q;
                 });
@@ -554,7 +554,7 @@ export function createGraphStore(db, adapter) {
                     query = query.where('owner', 'in', effectiveOwners);
                 }
                 if (filter != null) {
-                    query = query.where((eb)=>applyDocumentFilter(eb, filter, [], coerce));
+                    query = query.where((eb)=>applyDocumentFilter(eb, filter, adapter, [], coerce));
                 }
                 if (readAccess != null) {
                     query = query.where(adapter.readAccessPredicate(readAccess, modelID));
@@ -608,7 +608,7 @@ export function createGraphStore(db, adapter) {
                     query = query.where('owner', 'in', effectiveOwners);
                 }
                 if (filter != null) {
-                    query = query.where((eb)=>applyDocumentFilter(eb, filter, [], coerce));
+                    query = query.where((eb)=>applyDocumentFilter(eb, filter, adapter, [], coerce));
                 }
                 if (readAccess != null) {
                     query = query.where(adapter.readAccessPredicate(readAccess, modelID));

package/lib/query-builder.d.ts

@@ -17,8 +17,9 @@ export declare function applyGroupBySelections(eb: DocumentExpressionBuilder, gr
     expressions: Array<DocumentExpressionWrapper>;
 };
 export declare function applyPagination(query: DocumentQueryBuilder, args: ConnectionArguments, orderBy?: DocumentOrderBy, coerce?: CoerceFilterValue): [DocumentQueryBuilder, number];
-export declare function applyDocumentFilter(eb: DocumentExpressionBuilder, filter: DocumentFilter, path?: Array<string>, coerce?: CoerceFilterValue): DocumentExpressionWrapper;
-export declare function applyValueFilter(eb: DocumentExpressionBuilder, keys: Array<string>, filter: AnyValueFilter, coerce?: CoerceFilterValue): DocumentExpressionWrapper;
+export declare function applyDocumentFilter(eb: DocumentExpressionBuilder, filter: DocumentFilter, adapter: Adapter, path?: Array<string>, coerce?: CoerceFilterValue): DocumentExpressionWrapper;
+export declare function escapeLikePattern(value: string): string;
+export declare function applyValueFilter(eb: DocumentExpressionBuilder, keys: Array<string>, filter: AnyValueFilter, adapter: Adapter, coerce?: CoerceFilterValue): DocumentExpressionWrapper;
 export declare function applyDocumentOrderBy(queryBuilder: DocumentQueryBuilder, adapter: Adapter, orderBy?: DocumentOrderBy, isReverse?: boolean): [DocumentQueryBuilder, Array<Array<string>> | null];
 export declare const KNOWN_FIELDS: {
     readonly _createdAt: "created_at";

package/lib/query-builder.js

@@ -12,6 +12,16 @@ function getKeyPath(eb, keys) {
     }
     return keyPath;
 }
+// Same traversal as getKeyPath, but keeps the raw JSON node (`->`) instead of extracting
+// text (`->>`), so array-membership predicates can hand adapters a JSON array to iterate
+// (json_each / jsonb_array_elements_text / `@>`) rather than a text scalar.
+function getRawKeyPath(eb, keys) {
+    let keyPath = eb.ref('data', '->');
+    for (const key of keys){
+        keyPath = keyPath.key(key);
+    }
+    return keyPath;
+}
 export function aggregateFieldName(keys) {
     return keys.join('.');
 }
@@ -220,7 +230,7 @@ function applyBackwardPagination(queryBuilder, limit, before, orderBy, coerce) {
     }
     return query.limit(limit);
 }
-export function applyDocumentFilter(eb, filter, path = [], coerce) {
+export function applyDocumentFilter(eb, filter, adapter, path = [], coerce) {
     const entries = Object.entries(filter);
     if (entries.length !== 1) {
         throw new Error('Invalid document filter');
@@ -228,33 +238,40 @@ export function applyDocumentFilter(eb, filter, path = [], coerce) {
     const [type, value] = entries[0];
     switch(type){
         case 'where':
-            return applyObjectFilter(eb, value, path, coerce);
+            return applyObjectFilter(eb, value, adapter, path, coerce);
         case 'and':
             return eb.and(value.map((filter)=>{
-                return applyDocumentFilter(eb, filter, path, coerce);
+                return applyDocumentFilter(eb, filter, adapter, path, coerce);
             }));
         case 'or':
             return eb.or(value.map((filter)=>{
-                return applyDocumentFilter(eb, filter, path, coerce);
+                return applyDocumentFilter(eb, filter, adapter, path, coerce);
             }));
         case 'not':
-            return eb.not(applyDocumentFilter(eb, value, path, coerce));
+            return eb.not(applyDocumentFilter(eb, value, adapter, path, coerce));
         default:
             throw new Error(`Invalid document filter type: ${type}`);
     }
 }
-function applyObjectFilter(eb, filter, path, coerce) {
+function applyObjectFilter(eb, filter, adapter, path, coerce) {
     const criteria = Object.entries(filter).map(([fieldName, valueFilter])=>{
         // TODO: check if value filter or nested object filter should be applied
         // for nested object, check if embedded or related object
         return applyValueFilter(eb, [
             ...path,
             fieldName
-        ], valueFilter, coerce);
+        ], valueFilter, adapter, coerce);
     });
     return eb.and(criteria);
 }
-export function applyValueFilter(eb, keys, filter, coerce) {
+// Escapes a LIKE pattern's special characters (backslash first, then the wildcards) and
+// wraps it for substring match. Order matters: escaping `%`/`_` before the backslash
+// would double-escape them.
+export function escapeLikePattern(value) {
+    const escaped = value.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_');
+    return `%${escaped}%`;
+}
+export function applyValueFilter(eb, keys, filter, adapter, coerce) {
     const entries = Object.entries(filter);
     if (entries.length !== 1) {
         throw new Error('Invalid value filter');
@@ -281,6 +298,29 @@ export function applyValueFilter(eb, keys, filter, coerce) {
             return eb(fieldName, '>', c(value));
         case 'greaterThanOrEqualTo':
             return eb(fieldName, '>=', c(value));
+        case 'contains':
+            return adapter.containsPredicate(fieldName, escapeLikePattern(String(value)));
+        case 'includesAll':
+            {
+                // Dedupe the candidate set so SQLite's COUNT(DISTINCT value) = set-size test matches
+                // Postgres @> containment: duplicate inputs must not inflate the required count.
+                const items = [
+                    ...new Set(value)
+                ];
+                // Vacuously true (D7): every array includes the empty set. Handled here, not in
+                // SQL, so the adapter seam never sees an empty IN-list.
+                return items.length === 0 ? sql`1 = 1` : adapter.arrayIncludesAllPredicate(getRawKeyPath(eb, keys), items);
+            }
+        case 'includesAny':
+            {
+                const items = [
+                    ...new Set(value)
+                ];
+                // An empty candidate set matches nothing.
+                return items.length === 0 ? sql`1 = 0` : adapter.arrayIncludesAnyPredicate(getRawKeyPath(eb, keys), items);
+            }
+        case 'presence':
+            return adapter.arrayPresencePredicate(getRawKeyPath(eb, keys), value);
         default:
             throw new Error(`Invalid value filter type: ${type}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/store-graph",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -16,16 +16,19 @@
   ],
   "dependencies": {
     "@sozai/codec": "^0.4.0",
-    "kysely": "^0.29.4",
-    "@kubun/db": "^0.12.0",
-    "@kubun/db-adapter": "^0.12.0",
-    "@kubun/protocol": "^0.12.0",
+    "kysely": "^0.29.5",
+    "@kubun/db": "^0.12.1",
+    "@kubun/protocol": "^0.13.0",
+    "@kubun/db-adapter": "^0.13.0",
     "@kubun/id": "^0.12.0"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
-    "@kubun/db-better-sqlite": "^0.12.0",
-    "@kubun/db-postgres": "^0.12.0"
+    "@kubun/db-better-sqlite": "^0.12.1",
+    "@kubun/db-postgres": "^0.12.1"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",