@kubun/store-graph 0.10.2 → 0.11.0

package/lib/cursor.d.ts

@@ -2,6 +2,7 @@ export type CursorData = {
     id: string;
     ts?: number;
     values?: Record<string, unknown>;
+    nullKeys?: Array<string>;
 };
 export declare function parseCursor(cursor: string): CursorData;
 export declare function serializeCursor(data: CursorData): string;

package/lib/cursor.js

@@ -1 +1,7 @@
-import{b64uFromJSON as r,b64uToJSON as e}from"@enkaku/codec";export function parseCursor(r){return e(r)}export function serializeCursor(e){return r(e)}
+import { b64uFromJSON, b64uToJSON } from '@sozai/codec';
+export function parseCursor(cursor) {
+    return b64uToJSON(cursor);
+}
+export function serializeCursor(data) {
+    return b64uFromJSON(data);
+}

package/lib/definition.js

@@ -1 +1,7 @@
-import{createGraphStore as r}from"./api.js";import{getGraphMigrations as i}from"./migrations.js";export const graphStoreDefinition={name:"graph",migrations:i,createAPI:r};
+import { createGraphStore } from './api.js';
+import { getGraphMigrations } from './migrations.js';
+export const graphStoreDefinition = {
+    name: 'graph',
+    migrations: getGraphMigrations,
+    createAPI: createGraphStore
+};

package/lib/index.js

@@ -1 +1,6 @@
-export{createGraphStore}from"./api.js";export{graphStoreDefinition}from"./definition.js";export const GRAPH_STORE="graph";export function getGraphStore(r){return r.getStore("graph")}
+export { createGraphStore } from './api.js';
+export { graphStoreDefinition } from './definition.js';
+export const GRAPH_STORE = 'graph';
+export function getGraphStore(provider) {
+    return provider.getStore(GRAPH_STORE);
+}

package/lib/migrations.js

@@ -1 +1,62 @@
-export function getGraphMigrations(e){let t=e.types,a=e.functions.now;return{"0-init":{async up(e){await e.schema.createTable("kubun_graph_document_attachments").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("data",t.binary,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a).notNull()).execute(),await e.schema.createTable("kubun_graph_document_models").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("version",t.text,e=>e.notNull()).addColumn("name",t.text,e=>e.notNull()).addColumn("behavior",t.text,e=>e.notNull()).addColumn("unique_fields",t.json).addColumn("interfaces",t.json,e=>e.notNull()).addColumn("schema",t.json,e=>e.notNull()).addColumn("fields_meta",t.json,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a).notNull()).execute(),await e.schema.createTable("kubun_graph_document_model_interfaces").ifNotExists().addColumn("interface_id",t.text,e=>e.notNull().references("kubun_graph_document_models.id")).addColumn("implementation_id",t.text,e=>e.notNull().references("kubun_graph_document_models.id")).addUniqueConstraint("kubun_graph_document_model_interfaces_pkey",["interface_id","implementation_id"]).execute(),await e.schema.createTable("kubun_graph_models").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("name",t.text,e=>e.notNull()).addColumn("aliases",t.json,e=>e.defaultTo("{}").notNull()).addColumn("search",t.json).addColumn("extension_sdl",t.text).addColumn("plugin_config",t.json).addColumn("created_at",t.timestamp,e=>e.defaultTo(a).notNull()).addColumn("updated_at",t.timestamp).execute(),await e.schema.createTable("kubun_graph_document_model_links").ifNotExists().addColumn("graph_model_id",t.text,e=>e.notNull().references("kubun_graph_models.id")).addColumn("document_model_id",t.text,e=>e.notNull().references("kubun_graph_document_models.id")).addUniqueConstraint("kubun_graph_document_model_links_pkey",["graph_model_id","document_model_id"]).execute(),await e.schema.createTable("kubun_graph_user_model_access_defaults").ifNotExists().addColumn("owner_did",t.text,e=>e.notNull()).addColumn("model_id",t.text,e=>e.notNull()).addColumn("permission_type",t.text,e=>e.notNull()).addColumn("access_level",t.text,e=>e.notNull()).addColumn("allowed_dids",t.json).addColumn("allowed_circles",t.json).addColumn("allowed_groups",t.json).addColumn("created_at",t.timestamp,e=>e.defaultTo(a).notNull()).addColumn("updated_at",t.timestamp).addPrimaryKeyConstraint("kubun_graph_user_model_access_defaults_pkey",["owner_did","model_id","permission_type"]).execute(),await e.schema.createIndex("idx_graph_user_model_access_owner_model").on("kubun_graph_user_model_access_defaults").columns(["owner_did","model_id"]).execute(),await e.schema.createTable("kubun_graph_mutation_log").ifNotExists().addColumn("mutation_hash",t.text,e=>e.primaryKey()).addColumn("model_id",t.text,e=>e.notNull()).addColumn("document_id",t.text,e=>e.notNull()).addColumn("author_did",t.text,e=>e.notNull()).addColumn("hlc",t.text,e=>e.notNull()).addColumn("mutation_jwt",t.text,e=>e.notNull()).addColumn("status",t.text,e=>e.notNull().defaultTo("applied")).execute(),await e.schema.createIndex("idx_graph_mutation_log_hlc").on("kubun_graph_mutation_log").column("hlc").execute(),await e.schema.createIndex("idx_graph_mutation_log_document").on("kubun_graph_mutation_log").column("document_id").execute(),await e.schema.createIndex("idx_graph_mutation_log_status").on("kubun_graph_mutation_log").column("status").execute(),await e.schema.createTable("kubun_graph_cluster_models").ifNotExists().addColumn("model_id",t.text,e=>e.notNull().primaryKey()).addColumn("cluster_id",t.text,e=>e.notNull()).addColumn("cluster_index","integer",e=>e.notNull()).execute(),await e.schema.createIndex("idx_graph_cluster_models_cluster").on("kubun_graph_cluster_models").column("cluster_id").execute(),await e.schema.createTable("kubun_graph_clusters").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("definition",t.json,e=>e.notNull()).execute(),await e.schema.createTable("kubun_graph_catalogs").ifNotExists().addColumn("id",t.text,e=>e.notNull().primaryKey()).addColumn("owner_did",t.text,e=>e.notNull()).addColumn("name",t.text,e=>e.notNull()).addColumn("description",t.text,e=>e.notNull().defaultTo("")).addColumn("filter_criteria",t.json,e=>e.notNull()).addColumn("hlc",t.text,e=>e.notNull()).addColumn("created_at",t.timestamp,e=>e.defaultTo(a).notNull()).addColumn("updated_at",t.timestamp).execute(),await e.schema.createIndex("idx_graph_catalogs_owner").ifNotExists().on("kubun_graph_catalogs").column("owner_did").execute()},async down(e){await e.schema.dropTable("kubun_graph_catalogs").ifExists().execute(),await e.schema.dropTable("kubun_graph_clusters").ifExists().execute(),await e.schema.dropTable("kubun_graph_cluster_models").ifExists().execute(),await e.schema.dropTable("kubun_graph_mutation_log").ifExists().execute(),await e.schema.dropTable("kubun_graph_user_model_access_defaults").ifExists().execute(),await e.schema.dropTable("kubun_graph_document_model_links").ifExists().execute(),await e.schema.dropTable("kubun_graph_models").ifExists().execute(),await e.schema.dropTable("kubun_graph_document_model_interfaces").ifExists().execute(),await e.schema.dropTable("kubun_graph_document_models").ifExists().execute(),await e.schema.dropTable("kubun_graph_document_attachments").ifExists().execute()}}}}
+export function getGraphMigrations(ctx) {
+    const t = ctx.types;
+    const now = ctx.functions.now;
+    const init = {
+        async up (db) {
+            // Document attachments
+            await db.schema.createTable('kubun_graph_document_attachments').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('data', t.binary, (col)=>col.notNull()).addColumn('created_at', t.timestamp, (col)=>col.defaultTo(now).notNull()).execute();
+            // Document models
+            await db.schema.createTable('kubun_graph_document_models').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('version', t.text, (col)=>col.notNull()).addColumn('name', t.text, (col)=>col.notNull()).addColumn('behavior', t.text, (col)=>col.notNull()).addColumn('unique_fields', t.json).addColumn('interfaces', t.json, (col)=>col.notNull()).addColumn('schema', t.json, (col)=>col.notNull()).addColumn('fields_meta', t.json, (col)=>col.notNull()).addColumn('created_at', t.timestamp, (col)=>col.defaultTo(now).notNull()).execute();
+            // Document model interfaces
+            await db.schema.createTable('kubun_graph_document_model_interfaces').ifNotExists().addColumn('interface_id', t.text, (col)=>col.notNull().references('kubun_graph_document_models.id')).addColumn('implementation_id', t.text, (col)=>col.notNull().references('kubun_graph_document_models.id')).addUniqueConstraint('kubun_graph_document_model_interfaces_pkey', [
+                'interface_id',
+                'implementation_id'
+            ]).execute();
+            // Graph models
+            await db.schema.createTable('kubun_graph_models').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('name', t.text, (col)=>col.notNull()).addColumn('aliases', t.json, (col)=>col.defaultTo('{}').notNull()).addColumn('search', t.json).addColumn('extension_sdl', t.text).addColumn('plugin_config', t.json).addColumn('created_at', t.timestamp, (col)=>col.defaultTo(now).notNull()).addColumn('updated_at', t.timestamp).execute();
+            // Graph document model links (junction: graph-model ↔ document-model)
+            await db.schema.createTable('kubun_graph_document_model_links').ifNotExists().addColumn('graph_model_id', t.text, (col)=>col.notNull().references('kubun_graph_models.id')).addColumn('document_model_id', t.text, (col)=>col.notNull().references('kubun_graph_document_models.id')).addUniqueConstraint('kubun_graph_document_model_links_pkey', [
+                'graph_model_id',
+                'document_model_id'
+            ]).execute();
+            // User model access defaults
+            await db.schema.createTable('kubun_graph_user_model_access_defaults').ifNotExists().addColumn('owner_did', t.text, (col)=>col.notNull()).addColumn('model_id', t.text, (col)=>col.notNull()).addColumn('permission_type', t.text, (col)=>col.notNull()).addColumn('access_level', t.text, (col)=>col.notNull()).addColumn('allowed_dids', t.json).addColumn('allowed_circles', t.json).addColumn('allowed_groups', t.json).addColumn('created_at', t.timestamp, (col)=>col.defaultTo(now).notNull()).addColumn('updated_at', t.timestamp).addPrimaryKeyConstraint('kubun_graph_user_model_access_defaults_pkey', [
+                'owner_did',
+                'model_id',
+                'permission_type'
+            ]).execute();
+            await db.schema.createIndex('idx_graph_user_model_access_owner_model').ifNotExists().on('kubun_graph_user_model_access_defaults').columns([
+                'owner_did',
+                'model_id'
+            ]).execute();
+            // Mutation log
+            await db.schema.createTable('kubun_graph_mutation_log').ifNotExists().addColumn('mutation_hash', t.text, (col)=>col.primaryKey()).addColumn('model_id', t.text, (col)=>col.notNull()).addColumn('document_id', t.text, (col)=>col.notNull()).addColumn('author_did', t.text, (col)=>col.notNull()).addColumn('hlc', t.text, (col)=>col.notNull()).addColumn('mutation_jwt', t.text, (col)=>col.notNull()).addColumn('status', t.text, (col)=>col.notNull().defaultTo('applied')).execute();
+            await db.schema.createIndex('idx_graph_mutation_log_hlc').ifNotExists().on('kubun_graph_mutation_log').column('hlc').execute();
+            await db.schema.createIndex('idx_graph_mutation_log_document').ifNotExists().on('kubun_graph_mutation_log').column('document_id').execute();
+            await db.schema.createIndex('idx_graph_mutation_log_status').ifNotExists().on('kubun_graph_mutation_log').column('status').execute();
+            // Cluster models (model -> cluster mapping)
+            await db.schema.createTable('kubun_graph_cluster_models').ifNotExists().addColumn('model_id', t.text, (col)=>col.notNull().primaryKey()).addColumn('cluster_id', t.text, (col)=>col.notNull()).addColumn('cluster_index', 'integer', (col)=>col.notNull()).execute();
+            await db.schema.createIndex('idx_graph_cluster_models_cluster').ifNotExists().on('kubun_graph_cluster_models').column('cluster_id').execute();
+            // Cluster definitions
+            await db.schema.createTable('kubun_graph_clusters').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('definition', t.json, (col)=>col.notNull()).execute();
+            // Catalogs
+            await db.schema.createTable('kubun_graph_catalogs').ifNotExists().addColumn('id', t.text, (col)=>col.notNull().primaryKey()).addColumn('owner_did', t.text, (col)=>col.notNull()).addColumn('name', t.text, (col)=>col.notNull()).addColumn('description', t.text, (col)=>col.notNull().defaultTo('')).addColumn('filter_criteria', t.json, (col)=>col.notNull()).addColumn('hlc', t.text, (col)=>col.notNull()).addColumn('created_at', t.timestamp, (col)=>col.defaultTo(now).notNull()).addColumn('updated_at', t.timestamp).execute();
+            await db.schema.createIndex('idx_graph_catalogs_owner').ifNotExists().on('kubun_graph_catalogs').column('owner_did').execute();
+        },
+        async down (db) {
+            await db.schema.dropTable('kubun_graph_catalogs').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_clusters').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_cluster_models').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_mutation_log').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_user_model_access_defaults').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_document_model_links').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_models').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_document_model_interfaces').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_document_models').ifExists().execute();
+            await db.schema.dropTable('kubun_graph_document_attachments').ifExists().execute();
+        }
+    };
+    return {
+        '0-init': init
+    };
+}

package/lib/query-builder.d.ts

@@ -1,6 +1,6 @@
 import type { Adapter } from '@kubun/db-adapter';
 import type { AggregateSpec, AnyValueFilter, DocumentFilter, DocumentOrderBy } from '@kubun/protocol';
-import type { AliasedExpression, ExpressionBuilder, ExpressionWrapper, SelectQueryBuilder } from 'kysely';
+import { type AliasedExpression, type ExpressionBuilder, type ExpressionWrapper, type SelectQueryBuilder } from 'kysely';
 import type { ConnectionArguments, Document, GraphTables } from './tables.js';
 export type CoerceFilterValue = (value: unknown) => unknown;
 type DocumentExpressionBuilder = ExpressionBuilder<GraphTables, 'k_document'>;
@@ -16,8 +16,14 @@ export declare function applyGroupBySelections(eb: DocumentExpressionBuilder, gr
     selections: Array<AggregateSelection>;
     expressions: Array<DocumentExpressionWrapper>;
 };
-export declare function applyPagination(query: DocumentQueryBuilder, args: ConnectionArguments, orderBy?: DocumentOrderBy): [DocumentQueryBuilder, number];
+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 applyDocumentOrderBy(queryBuilder: DocumentQueryBuilder, orderBy?: DocumentOrderBy, isReverse?: boolean): [DocumentQueryBuilder, Array<Array<string>> | null];
+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";
+    readonly _docOwner: "owner";
+};
+export type KnownFieldColumn = (typeof KNOWN_FIELDS)[keyof typeof KNOWN_FIELDS];
+export declare function knownFieldColumn(keys: Array<string>): KnownFieldColumn | undefined;
 export {};

package/lib/query-builder.js

@@ -1 +1,370 @@
-import{parseCursor as e}from"./cursor.js";function t(e=50){return Math.min(e,100)}function r(e,t){let r=e.ref("data","->>");for(let e of t)r=r.key(e);return r}export function aggregateFieldName(e){return e.join(".")}export function applyAggregateSelections(e,t,n){let a=[];for(let l of t){let t=aggregateFieldName(l.keys),o=r(e,l.keys),u=l.numeric?n.numericCast(o):o;switch(l.op){case"sum":a.push(e.fn.sum(u).as(`sum_${t}`));break;case"average":a.push(e.fn.sum(u).as(`sum_${t}`)),a.push(e.fn.count(u).as(`count_${t}`));break;case"min":a.push(e.fn.min(u).as(`min_${t}`));break;case"max":a.push(e.fn.max(u).as(`max_${t}`));break;default:throw Error(`Invalid aggregate op: ${l.op}`)}}return a}export function groupKeyAlias(e){return`key_${e.join(".")}`}export function applyGroupBySelections(e,t){let n=[],a=[];for(let l of t){let t=r(e,l.keys);n.push(t.as(groupKeyAlias(l.keys))),a.push(t)}return{selections:n,expressions:a}}function n(e){let t=[],r=e;do{let[e,n]=Object.entries(r)[0];if(t.push(e),"string"==typeof n)return{keys:t,direction:n};r=n}while(null!=r)throw Error("Could not extract field entry")}function a(e,t=!1){return t?"asc"===e?"desc":"asc":e}export function applyPagination(a,l,o=[]){let{first:u,last:i,before:s,after:c}=l;if(null!=u){let l=t(u);return[function(t,a,l,o){let u=t;if(null!=l){let{id:t,ts:a,values:i}=e(l);null!=a?u=u.where(e=>e.or([e("created_at",">",a),e("created_at","=",a).and("id",">",t)])):null!=i&&(u=u.where(e=>{let a=[];for(let l of o){let o=n(l),u=i[o.keys.join(".")];if(null==u)continue;let s=r(e,o.keys);a.push(e.or([e(s,"asc"===o.direction?">":"<",u),e(s,"=",u).and("id",">",t)]))}return e.and(a)}))}return u.orderBy("created_at","asc").limit(a)}(a,l+1,c,o),l]}if(null!=i){let l=t(i);return[function(t,a,l,o){let u=t;if(null!=l){let{id:t,ts:a,values:i}=e(l);null!=a?u=u.where(e=>e.or([e("created_at","<",a),e("created_at","=",a).and("id","<",t)])):null!=i&&(u=u.where(e=>{let a=[];for(let l of o){let o=n(l),u=i[o.keys.join(".")];if(null==u)continue;let s=r(e,o.keys);a.push(e.or([e(s,"asc"===o.direction?"<":">",u),e(s,"=",u).and("id",">",t)]))}return e.and(a)}))}return u.orderBy("created_at","desc").limit(a)}(a,l+1,s,o),l]}let f=t();return[a.orderBy("created_at","asc").limit(f+1),f]}export function applyDocumentFilter(e,t,r=[],n){let a=Object.entries(t);if(1!==a.length)throw Error("Invalid document filter");let[l,o]=a[0];switch(l){case"where":var u,i,s,c;let f;return u=e,i=o,s=r,c=n,f=Object.entries(i).map(([e,t])=>applyValueFilter(u,[...s,e],t,c)),u.and(f);case"and":return e.and(o.map(t=>applyDocumentFilter(e,t,r,n)));case"or":return e.or(o.map(t=>applyDocumentFilter(e,t,r,n)));case"not":return e.not(applyDocumentFilter(e,o,r,n));default:throw Error(`Invalid document filter type: ${l}`)}}export function applyValueFilter(e,t,n,a){let l=Object.entries(n);if(1!==l.length)throw Error("Invalid value filter");let o=r(e,t),[u,i]=l[0],s=a??(e=>e);switch(u){case"isNull":return e(o,!0===i?"is":"is not",null);case"equalTo":return e(o,"=",s(i));case"notEqualTo":return e(o,"!=",s(i));case"in":return e(o,"in",i.map(s));case"notIn":return e(o,"not in",i.map(s));case"lessThan":return e(o,"<",s(i));case"lessThanOrEqualTo":return e(o,"<=",s(i));case"greaterThan":return e(o,">",s(i));case"greaterThanOrEqualTo":return e(o,">=",s(i));default:throw Error(`Invalid value filter type: ${u}`)}}export function applyDocumentOrderBy(e,t=[],n=!1){if(0===t.length)return[e.orderBy("created_at",a("asc",n)),null];let o=e,u=[];for(let e of t){let[t,i]=function e(t,n,o,u=[]){let i=Object.entries(n);if(1!==i.length)throw Error("Invalid order by field");let[s,c]=i[0],f=[...u,s],p=l[s];return null!=p?[t.orderBy(p,a(c,o)),f]:"string"==typeof c?[t.orderBy(e=>r(e,f),a(c,o)),f]:e(t,c,o,f)}(o,e,n);o=t,u.push(i)}return[o,u]}let l={_createdAt:"created_at",_owner:"owner"};
+import { sql } from 'kysely';
+import { parseCursor } from './cursor.js';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 100;
+function getLimit(value = DEFAULT_LIMIT) {
+    return Math.min(value, MAX_LIMIT);
+}
+function getKeyPath(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('.');
+}
+export function applyAggregateSelections(eb, specs, adapter) {
+    const selections = [];
+    for (const spec of specs){
+        const field = aggregateFieldName(spec.keys);
+        const raw = getKeyPath(eb, spec.keys);
+        const value = spec.numeric ? adapter.numericCast(raw) : raw;
+        switch(spec.op){
+            case 'sum':
+                selections.push(eb.fn.sum(value).as(`sum_${field}`));
+                break;
+            case 'average':
+                selections.push(eb.fn.sum(value).as(`sum_${field}`));
+                selections.push(eb.fn.count(value).as(`count_${field}`));
+                break;
+            case 'min':
+                selections.push(eb.fn.min(value).as(`min_${field}`));
+                break;
+            case 'max':
+                selections.push(eb.fn.max(value).as(`max_${field}`));
+                break;
+            default:
+                throw new Error(`Invalid aggregate op: ${spec.op}`);
+        }
+    }
+    return selections;
+}
+export function groupKeyAlias(keys) {
+    return `key_${keys.join('.')}`;
+}
+// Builds the aliased group-key select expressions plus the matching GROUP BY
+// expressions. Grouping is on the raw text extraction (no numeric cast): equality
+// bucketing is correct on text, and the JSON encoder serialises a given value
+// identically across model tables.
+export function applyGroupBySelections(eb, groupBy) {
+    const selections = [];
+    const expressions = [];
+    for (const group of groupBy){
+        const raw = getKeyPath(eb, group.keys);
+        selections.push(raw.as(groupKeyAlias(group.keys)));
+        expressions.push(raw);
+    }
+    return {
+        selections,
+        expressions
+    };
+}
+function getOrderByFieldEntry(field) {
+    const keys = [];
+    let current = field;
+    do {
+        const [key, value] = Object.entries(current)[0];
+        keys.push(key);
+        if (typeof value === 'string') {
+            return {
+                keys,
+                direction: value
+            };
+        }
+        current = value;
+    }while (current != null)
+    throw new Error('Could not extract field entry');
+}
+function orderByDirection(direction, isReversed = false) {
+    return isReversed ? direction === 'asc' ? 'desc' : 'asc' : direction;
+}
+export function applyPagination(query, args, orderBy = [], coerce) {
+    const { first, last, before, after } = args;
+    if (first != null) {
+        const limit = getLimit(first);
+        return [
+            applyForwardPagination(query, limit + 1, after, orderBy, coerce),
+            limit
+        ];
+    }
+    if (last != null) {
+        const limit = getLimit(last);
+        return [
+            applyBackwardPagination(query, limit + 1, before, orderBy, coerce),
+            limit
+        ];
+    }
+    const limit = getLimit();
+    return [
+        query.limit(limit + 1),
+        limit
+    ];
+}
+// Resolves an ordered field to the same SQL expression the ORDER BY uses, so the
+// keyset predicate compares against the exact column being sorted. Known fields map
+// to real columns (created_at, owner); everything else is a JSON path extraction.
+function orderByFieldExpression(eb, keys) {
+    const knownField = knownFieldColumn(keys);
+    if (knownField != null) {
+        return eb.ref(knownField);
+    }
+    return getKeyPath(eb, keys);
+}
+// The term selecting rows that strictly advance past the cursor on this field (prior
+// fields equal). Encodes the null bucket per SQL-standard position:
+//   ascending (nulls last):  cursor non-null -> f > v OR f IS NULL ; cursor null -> nothing
+//   descending (nulls first): cursor non-null -> f < v             ; cursor null -> f IS NOT NULL
+function advanceTerm(eb, field) {
+    if (field.value == null) {
+        // Ascending nulls sort last, so nothing advances past a null cursor on this field.
+        return field.ascending ? sql`1 = 0` : eb(field.expr, 'is not', null);
+    }
+    if (field.ascending) {
+        return eb.or([
+            eb(field.expr, '>', field.value),
+            eb(field.expr, 'is', null)
+        ]);
+    }
+    return eb(field.expr, '<', field.value);
+}
+// The term selecting rows that tie this field with the cursor (continue to the next
+// field). A null cursor value ties with other null rows.
+function equalTerm(eb, field) {
+    return field.value == null ? eb(field.expr, 'is', null) : eb(field.expr, '=', field.value);
+}
+// Builds the lexicographic keyset predicate that pairs with an ORDER BY whose terminal
+// column is `id`. For ORDER BY (f1..fn, id) the rows strictly after the cursor are:
+//   advance(f1)
+//   OR (eq(f1) AND advance(f2))
+//   ...
+//   OR (eq(f1) AND ... AND eq(fn) AND id idCmp idCursor)
+// The tie-break on `id` guarantees no duplicate or skipped row when ordered values
+// repeat. Null ordered values stay in the chain (tagged via `nullKeys`) and sort in
+// SQL-standard position, so concatenated pages match the full ordered set across the
+// null boundary. `forward` true is a forward scan; false flips every field's effective
+// direction (and thus its null position) for a reversed scan.
+function buildKeysetPredicate(eb, orderBy, values, nullKeys, id, forward, coerce) {
+    // Cursor comparison values must be coerced the same way filter values are: a JSON
+    // path extraction (`data ->> field`) yields adapter-specific text/integer forms
+    // (e.g. 1/0 for booleans on SQLite), so an uncoerced cursor value would misfire and
+    // drift pages. Known-column fields (created_at, owner) are not JSON-extracted.
+    const c = coerce ?? ((v)=>v);
+    const nullSet = new Set(nullKeys);
+    const fields = [];
+    for (const orderByField of orderBy){
+        const entry = getOrderByFieldEntry(orderByField);
+        const key = entry.keys.join('.');
+        const ascending = entry.direction === 'asc' === forward;
+        const isKnownField = knownFieldColumn(entry.keys) != null;
+        // A key absent from both buckets (stale or malformed cursor) is treated as the null
+        // bucket rather than binding an undefined comparison value.
+        const isNull = nullSet.has(key) || !(key in values);
+        const rawValue = values[key];
+        fields.push({
+            expr: orderByFieldExpression(eb, entry.keys),
+            value: isNull ? null : isKnownField ? rawValue : c(rawValue),
+            ascending
+        });
+    }
+    const idCmp = forward ? '>' : '<';
+    const clauses = [];
+    for(let level = 0; level < fields.length; level += 1){
+        const conjuncts = [];
+        for(let prior = 0; prior < level; prior += 1){
+            conjuncts.push(equalTerm(eb, fields[prior]));
+        }
+        conjuncts.push(advanceTerm(eb, fields[level]));
+        clauses.push(eb.and(conjuncts));
+    }
+    const tieBreak = [];
+    for (const field of fields){
+        tieBreak.push(equalTerm(eb, field));
+    }
+    tieBreak.push(eb('id', idCmp, id));
+    clauses.push(eb.and(tieBreak));
+    return eb.or(clauses);
+}
+function applyForwardPagination(queryBuilder, limit, after, orderBy, coerce) {
+    let query = queryBuilder;
+    if (after != null) {
+        const { id, ts, values, nullKeys } = parseCursor(after);
+        if (ts != null) {
+            query = query.where((eb)=>{
+                return eb.or([
+                    eb('created_at', '>', ts),
+                    eb('created_at', '=', ts).and('id', '>', id)
+                ]);
+            });
+        } else if (values != null || nullKeys != null) {
+            query = query.where((eb)=>buildKeysetPredicate(eb, orderBy, values ?? {}, nullKeys ?? [], id, true, coerce));
+        }
+    }
+    return query.limit(limit);
+}
+function applyBackwardPagination(queryBuilder, limit, before, orderBy, coerce) {
+    let query = queryBuilder;
+    if (before != null) {
+        const { id, ts, values, nullKeys } = parseCursor(before);
+        if (ts != null) {
+            query = query.where((eb)=>{
+                return eb.or([
+                    eb('created_at', '<', ts),
+                    eb('created_at', '=', ts).and('id', '<', id)
+                ]);
+            });
+        } else if (values != null || nullKeys != null) {
+            query = query.where((eb)=>buildKeysetPredicate(eb, orderBy, values ?? {}, nullKeys ?? [], id, false, coerce));
+        }
+    }
+    return query.limit(limit);
+}
+export function applyDocumentFilter(eb, filter, path = [], coerce) {
+    const entries = Object.entries(filter);
+    if (entries.length !== 1) {
+        throw new Error('Invalid document filter');
+    }
+    const [type, value] = entries[0];
+    switch(type){
+        case 'where':
+            return applyObjectFilter(eb, value, path, coerce);
+        case 'and':
+            return eb.and(value.map((filter)=>{
+                return applyDocumentFilter(eb, filter, path, coerce);
+            }));
+        case 'or':
+            return eb.or(value.map((filter)=>{
+                return applyDocumentFilter(eb, filter, path, coerce);
+            }));
+        case 'not':
+            return eb.not(applyDocumentFilter(eb, value, path, coerce));
+        default:
+            throw new Error(`Invalid document filter type: ${type}`);
+    }
+}
+function applyObjectFilter(eb, filter, 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);
+    });
+    return eb.and(criteria);
+}
+export function applyValueFilter(eb, keys, filter, coerce) {
+    const entries = Object.entries(filter);
+    if (entries.length !== 1) {
+        throw new Error('Invalid value filter');
+    }
+    const fieldName = getKeyPath(eb, keys);
+    const [type, value] = entries[0];
+    const c = coerce ?? ((v)=>v);
+    switch(type){
+        case 'isNull':
+            return eb(fieldName, value === true ? 'is' : 'is not', null);
+        case 'equalTo':
+            return eb(fieldName, '=', c(value));
+        case 'notEqualTo':
+            return eb(fieldName, '!=', c(value));
+        case 'in':
+            return eb(fieldName, 'in', value.map(c));
+        case 'notIn':
+            return eb(fieldName, 'not in', value.map(c));
+        case 'lessThan':
+            return eb(fieldName, '<', c(value));
+        case 'lessThanOrEqualTo':
+            return eb(fieldName, '<=', c(value));
+        case 'greaterThan':
+            return eb(fieldName, '>', c(value));
+        case 'greaterThanOrEqualTo':
+            return eb(fieldName, '>=', c(value));
+        default:
+            throw new Error(`Invalid value filter type: ${type}`);
+    }
+}
+export function applyDocumentOrderBy(queryBuilder, adapter, orderBy = [], isReverse = false) {
+    // `id` is the terminal sort column on every path so the cursor keyset can tie-break
+    // on a column that is actually part of the ORDER BY. Without it, repeated ordered
+    // values would let pagination duplicate or skip rows. `id` sorts in the scan
+    // direction (reversed when isReverse) so the keyset comparator stays consistent.
+    const idDirection = orderByDirection('asc', isReverse);
+    if (orderBy.length === 0) {
+        return [
+            queryBuilder.orderBy('created_at', idDirection).orderBy('id', idDirection),
+            null
+        ];
+    }
+    let query = queryBuilder;
+    const paths = [];
+    for (const entry of orderBy){
+        const [newQuery, path] = applyOrderByField(query, adapter, entry, isReverse);
+        query = newQuery;
+        paths.push(path);
+    }
+    query = query.orderBy('id', idDirection);
+    return [
+        query,
+        paths
+    ];
+}
+// Ordered fields that map directly to non-null table columns instead of a JSON-path
+// extraction out of `data`. Keys match the GraphQL orderBy field names; values are the
+// physical column names. Cursor construction must read these from the row column, not
+// from `data`, or the ordered value comes back undefined and the keyset predicate drops
+// every row past the first page.
+export const KNOWN_FIELDS = {
+    _createdAt: 'created_at',
+    _docOwner: 'owner'
+};
+export function knownFieldColumn(keys) {
+    if (keys.length !== 1) return undefined;
+    return KNOWN_FIELDS[keys[0]];
+}
+function applyOrderByField(query, adapter, orderBy, isReverse, path = []) {
+    const entries = Object.entries(orderBy);
+    if (entries.length !== 1) {
+        throw new Error('Invalid order by field');
+    }
+    const [key, value] = entries[0];
+    const keys = [
+        ...path,
+        key
+    ];
+    const knownField = knownFieldColumn(keys);
+    if (knownField != null) {
+        // Known columns (created_at, owner) are non-null, so no null positioning is needed.
+        return [
+            query.orderBy(knownField, orderByDirection(value, isReverse)),
+            keys
+        ];
+    }
+    if (typeof value !== 'string') {
+        return applyOrderByField(query, adapter, value, isReverse, keys);
+    }
+    // JSON-extracted fields can be null. Sort them in SQL-standard null position (last on
+    // ascending, first on descending) on every adapter via the adapter's null-ordering term.
+    const direction = orderByDirection(value, isReverse);
+    const probe = adapter.nullOrdering(sql`1`, direction);
+    if (probe.kind === 'lead') {
+        // Prepend an ascending rank column that buckets nulls last/first, then sort on the
+        // field itself. The rank expression embeds the field's own JSON-path extraction.
+        return [
+            query.orderBy((eb)=>adapterLeadExpression(adapter, eb, keys, direction), 'asc').orderBy((eb)=>getKeyPath(eb, keys), direction),
+            keys
+        ];
+    }
+    return [
+        query.orderBy((eb)=>getKeyPath(eb, keys), (ob)=>direction === 'asc' ? ob.asc().nullsLast() : ob.desc().nullsFirst()),
+        keys
+    ];
+}
+function adapterLeadExpression(adapter, eb, keys, direction) {
+    const term = adapter.nullOrdering(getKeyPath(eb, keys), direction);
+    if (term.kind !== 'lead') {
+        throw new Error('Expected a leading null-ordering term');
+    }
+    return term.expression;
+}

package/lib/tables.d.ts

@@ -10,6 +10,7 @@ export type DocumentTable<Data extends DocumentData = DocumentData> = {
     model: string;
     data: JSONValueColumn<Data> | null;
     field_hlcs: JSONValueColumn<Record<string, string>> | null;
+    field_values: JSONValueColumn<Record<string, unknown>> | null;
     unique: Uint8Array;
     created_at: CreatedAtColumn;
     updated_at: UpdatedAtColumn;

package/lib/tables.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/store-graph",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,21 +15,21 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/codec": "^0.16.0",
+    "@sozai/codec": "^0.1.0",
     "kysely": "^0.29.2",
-    "@kubun/db": "^0.10.0",
-    "@kubun/id": "^0.10.0",
-    "@kubun/db-adapter": "^0.10.0",
-    "@kubun/protocol": "^0.10.0"
+    "@kubun/db": "^0.11.0",
+    "@kubun/db-adapter": "^0.11.0",
+    "@kubun/id": "^0.11.0",
+    "@kubun/protocol": "^0.11.0"
   },
   "devDependencies": {
-    "@testcontainers/postgresql": "^12.0.1",
-    "@kubun/db-better-sqlite": "^0.10.0",
-    "@kubun/db-postgres": "^0.10.0"
+    "@testcontainers/postgresql": "^12.0.4",
+    "@kubun/db-better-sqlite": "^0.11.0",
+    "@kubun/db-postgres": "^0.11.0"
   },
   "scripts": {
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "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",