@kubun/db-adapter 0.10.0 → 0.12.0

package/lib/index.js

@@ -1 +1,2 @@
-export{AbstractPostgresAdapter}from"./postgres.js";export{AbstractSQLiteAdapter}from"./sqlite.js";
+export { AbstractPostgresAdapter } from './postgres.js';
+export { AbstractSQLiteAdapter } from './sqlite.js';

package/lib/postgres.d.ts

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

package/lib/postgres.js

@@ -1,37 +1,138 @@
-import{sql as e}from"kysely";export class AbstractPostgresAdapter{functions={now:"now()"};types={binary:"bytea",json:"jsonb",serial:"serial",text:"text",timestamp:"timestamptz(3)",uuid:"uuid"};encodeBinary(e){return e}encodeJSON(e){return e}encodeTimestamp(e){return e.toISOString()}decodeTimestamp(e){return new Date(e)}coerceFilterValue(e){return"boolean"==typeof e?e?"true":"false":e}numericCast(t){return e`(${t})::numeric`}readAccessPredicate(t,a){let{viewerDID:r,groupIDs:s,circleIDs:n,serverDefault:o}=t,_=[e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedDIDs', '[]'::jsonb)) AS _t WHERE _t = ${r})`];s.length>0&&_.push(e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedGroups', '[]'::jsonb)) AS _t WHERE _t IN (${e.join(s.map(t=>e`${t}`))}))`),n.length>0&&_.push(e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedCircles', '[]'::jsonb)) AS _t WHERE _t IN (${e.join(n.map(t=>e`${t}`))}))`);let d=_.reduce((t,a)=>e`${t} OR ${a}`),E=[e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_dids, '[]'::jsonb)) AS _t WHERE _t = ${r})`];s.length>0&&E.push(e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_groups, '[]'::jsonb)) AS _t WHERE _t IN (${e.join(s.map(t=>e`${t}`))}))`),n.length>0&&E.push(e`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_circles, '[]'::jsonb)) AS _t WHERE _t IN (${e.join(n.map(t=>e`${t}`))}))`);let c=E.reduce((t,a)=>e`${t} OR ${a}`),l="anyone"===o?e`true`:"only_owner"===o?e`owner = ${r}`:e`false`;return e`(
-      owner = ${r}
+import { sql } from 'kysely';
+export class AbstractPostgresAdapter {
+    functions = {
+        now: 'now()'
+    };
+    types = {
+        bigint: 'bigint',
+        binary: 'bytea',
+        json: 'jsonb',
+        serial: 'serial',
+        text: 'text',
+        // Use 3 digits for timestamps to have millisecond precision, same as JS dates
+        timestamp: 'timestamptz(3)',
+        uuid: 'uuid'
+    };
+    encodeBinary(value) {
+        return value;
+    }
+    encodeJSON(value) {
+        return value;
+    }
+    encodeTimestamp(value) {
+        return value.toISOString();
+    }
+    decodeTimestamp(value) {
+        return new Date(value);
+    }
+    coerceFilterValue(value) {
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        return value;
+    }
+    numericCast(expression) {
+        return sql`(${expression})::numeric`;
+    }
+    nullOrdering(_expression, _direction) {
+        // Postgres applies SQL-standard null position natively (NULLS LAST on asc, NULLS
+        // FIRST on desc) via the dialect's own clause on the field's order-by item.
+        return {
+            kind: 'native'
+        };
+    }
+    readAccessPredicate(params, modelID) {
+        const { viewerDID, groupIDs, circleIDs, serverDefault } = params;
+        const docRestrictedParts = [
+            sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedDIDs', '[]'::jsonb)) AS _t WHERE _t = ${viewerDID})`
+        ];
+        if (groupIDs.length > 0) {
+            docRestrictedParts.push(sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedGroups', '[]'::jsonb)) AS _t WHERE _t IN (${sql.join(groupIDs.map((id)=>sql`${id}`))}))`);
+        }
+        if (circleIDs.length > 0) {
+            docRestrictedParts.push(sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(data -> 'accessPermissions' -> 'read' -> 'allowedCircles', '[]'::jsonb)) AS _t WHERE _t IN (${sql.join(circleIDs.map((id)=>sql`${id}`))}))`);
+        }
+        const docRestricted = docRestrictedParts.reduce((a, b)=>sql`${a} OR ${b}`);
+        const madRestrictedParts = [
+            sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_dids, '[]'::jsonb)) AS _t WHERE _t = ${viewerDID})`
+        ];
+        if (groupIDs.length > 0) {
+            madRestrictedParts.push(sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_groups, '[]'::jsonb)) AS _t WHERE _t IN (${sql.join(groupIDs.map((id)=>sql`${id}`))}))`);
+        }
+        if (circleIDs.length > 0) {
+            madRestrictedParts.push(sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(COALESCE(_mad.allowed_circles, '[]'::jsonb)) AS _t WHERE _t IN (${sql.join(circleIDs.map((id)=>sql`${id}`))}))`);
+        }
+        const madRestricted = madRestrictedParts.reduce((a, b)=>sql`${a} OR ${b}`);
+        const serverDefaultCond = serverDefault === 'anyone' ? sql`true` : serverDefault === 'only_owner' ? sql`owner = ${viewerDID}` : sql`false`;
+        return sql`(
+      owner = ${viewerDID}
       OR (data -> 'accessPermissions' -> 'read' ->> 'level') = 'anyone'
-      OR ((data -> 'accessPermissions' -> 'read' ->> 'level') = 'only_owner' AND owner = ${r})
-      OR ((data -> 'accessPermissions' -> 'read' ->> 'level') = 'restricted' AND (${d}))
+      OR ((data -> 'accessPermissions' -> 'read' ->> 'level') = 'only_owner' AND owner = ${viewerDID})
+      OR ((data -> 'accessPermissions' -> 'read' ->> 'level') = 'restricted' AND (${docRestricted}))
       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 = ${a} AND _mad.permission_type = 'read'
+        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 = ${r})
-          OR (_mad.access_level = 'restricted' AND (${c}))
+          OR (_mad.access_level = 'only_owner' AND owner = ${viewerDID})
+          OR (_mad.access_level = 'restricted' AND (${madRestricted}))
         )
       ))
       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 = ${a} AND _mad2.permission_type = 'read'
-      ) AND (${l}))
-    )`}async createSearchIndex(t,a){let r=`fts_${a.modelID}`,s=`k_${a.modelID}`;await e`
-      CREATE TABLE IF NOT EXISTS ${e.ref(r)} (
-        document_id TEXT PRIMARY KEY REFERENCES ${e.ref(s)}(id) ON DELETE CASCADE,
+        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}))
+    )`;
+    }
+    async createSearchIndex(db, config) {
+        const tableName = `fts_${config.modelID}`;
+        const docTableName = `k_${config.modelID}`;
+        await sql`
+      CREATE TABLE IF NOT EXISTS ${sql.ref(tableName)} (
+        document_id TEXT PRIMARY KEY REFERENCES ${sql.ref(docTableName)}(id) ON DELETE CASCADE,
         search_vector tsvector
       )
-    `.execute(t),await e`
-      CREATE INDEX IF NOT EXISTS ${e.ref(`ftsi_${a.modelID}`)}
-      ON ${e.ref(r)} USING GIN(search_vector)
-    `.execute(t)}async dropSearchIndex(t,a){let r=`fts_${a}`;await e`DROP TABLE IF EXISTS ${e.ref(r)} CASCADE`.execute(t)}async updateSearchEntry(t,a,r,s,n){let o=`fts_${a}`,_=n.map(t=>{let a=s[t]??"";return e`to_tsvector('simple', ${a})`}).reduce((t,a)=>e`${t} || ${a}`);await e`
-      INSERT INTO ${e.ref(o)} (document_id, search_vector)
-      VALUES (${r}, ${_})
-      ON CONFLICT (document_id) DO UPDATE SET search_vector = ${_}
-    `.execute(t)}async removeSearchEntry(t,a,r){let s=`fts_${a}`;await e`DELETE FROM ${e.ref(s)} WHERE document_id = ${r}`.execute(t)}async searchIndex(t,a){let r=`fts_${a.modelID}`;return(await e`
-      SELECT document_id, ts_rank(search_vector, plainto_tsquery('simple', ${a.query})) AS rank
-      FROM ${e.ref(r)}
-      WHERE search_vector @@ plainto_tsquery('simple', ${a.query})
+    `.execute(db);
+        await sql`
+      CREATE INDEX IF NOT EXISTS ${sql.ref(`ftsi_${config.modelID}`)}
+      ON ${sql.ref(tableName)} USING GIN(search_vector)
+    `.execute(db);
+    }
+    async dropSearchIndex(db, modelID) {
+        const tableName = `fts_${modelID}`;
+        await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)} CASCADE`.execute(db);
+    }
+    async updateSearchEntry(db, modelID, documentID, fields, fieldNames) {
+        const tableName = `fts_${modelID}`;
+        const tsvectorParts = fieldNames.map((f)=>{
+            const value = fields[f] ?? '';
+            return sql`to_tsvector('simple', ${value})`;
+        });
+        const tsvectorExpr = tsvectorParts.reduce((acc, part)=>sql`${acc} || ${part}`);
+        await sql`
+      INSERT INTO ${sql.ref(tableName)} (document_id, search_vector)
+      VALUES (${documentID}, ${tsvectorExpr})
+      ON CONFLICT (document_id) DO UPDATE SET search_vector = ${tsvectorExpr}
+    `.execute(db);
+    }
+    async removeSearchEntry(db, modelID, documentID) {
+        const tableName = `fts_${modelID}`;
+        await sql`DELETE FROM ${sql.ref(tableName)} WHERE document_id = ${documentID}`.execute(db);
+    }
+    async searchIndex(db, params) {
+        const tableName = `fts_${params.modelID}`;
+        const results = await sql`
+      SELECT document_id, ts_rank(search_vector, plainto_tsquery('simple', ${params.query})) AS rank
+      FROM ${sql.ref(tableName)}
+      WHERE search_vector @@ plainto_tsquery('simple', ${params.query})
       ORDER BY rank DESC
-      LIMIT ${a.limit}
-    `.execute(t)).rows.map(e=>({documentID:e.document_id,rank:e.rank}))}}
+      LIMIT ${params.limit}
+    `.execute(db);
+        return results.rows.map((row)=>({
+                documentID: row.document_id,
+                rank: row.rank
+            }));
+    }
+}

package/lib/sqlite.d.ts

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

package/lib/sqlite.js

@@ -1,24 +1,135 @@
-import{sql as e}from"kysely";export class AbstractSQLiteAdapter{functions={now:e`(unixepoch())`};types={binary:"blob",json:"jsonb",serial:"integer",text:"text",timestamp:"integer",uuid:"text"};encodeBinary(e){return e}encodeJSON(e){return JSON.stringify(e)}encodeTimestamp(e){return Math.floor(e.getTime()/1e3)}decodeTimestamp(e){return new Date(1e3*e)}coerceFilterValue(e){return"boolean"==typeof e?+!!e:e}numericCast(a){return e`CAST(${a} AS REAL)`}readAccessPredicate(a,s){let{viewerDID:t,groupIDs:r,circleIDs:n,serverDefault:o}=a,d=[e`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedDIDs'), '[]')) WHERE value = ${t})`];r.length>0&&d.push(e`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedGroups'), '[]')) WHERE value IN (${e.join(r.map(a=>e`${a}`))}))`),n.length>0&&d.push(e`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedCircles'), '[]')) WHERE value IN (${e.join(n.map(a=>e`${a}`))}))`);let c=d.reduce((a,s)=>e`${a} OR ${s}`),E=[e`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_dids, '[]')) WHERE value = ${t})`];r.length>0&&E.push(e`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_groups, '[]')) WHERE value IN (${e.join(r.map(a=>e`${a}`))}))`),n.length>0&&E.push(e`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_circles, '[]')) WHERE value IN (${e.join(n.map(a=>e`${a}`))}))`);let i=E.reduce((a,s)=>e`${a} OR ${s}`),l="anyone"===o?e`1 = 1`:"only_owner"===o?e`owner = ${t}`:e`1 = 0`;return e`(
-      owner = ${t}
+import { sql } from 'kysely';
+export class AbstractSQLiteAdapter {
+    functions = {
+        now: sql`(unixepoch())`
+    };
+    types = {
+        bigint: 'integer',
+        binary: 'blob',
+        json: 'jsonb',
+        serial: 'integer',
+        text: 'text',
+        timestamp: 'integer',
+        uuid: 'text'
+    };
+    encodeBinary(value) {
+        return value;
+    }
+    encodeJSON(value) {
+        return JSON.stringify(value);
+    }
+    encodeTimestamp(value) {
+        // SQLite timestamps are stored in seconds
+        return Math.floor(value.getTime() / 1000);
+    }
+    decodeTimestamp(value) {
+        // SQLite timestamps are stored in seconds
+        return new Date(value * 1000);
+    }
+    coerceFilterValue(value) {
+        if (typeof value === 'boolean') {
+            return value ? 1 : 0;
+        }
+        return value;
+    }
+    numericCast(expression) {
+        return sql`CAST(${expression} AS REAL)`;
+    }
+    nullOrdering(expression, direction) {
+        // SQLite has no NULLS LAST/FIRST clause, so prepend an ascending rank column that
+        // buckets nulls last on ascending (rank 1 > 0) and first on descending (rank 0 < 1).
+        const nullRank = direction === 'asc' ? 1 : 0;
+        const valueRank = direction === 'asc' ? 0 : 1;
+        return {
+            kind: 'lead',
+            expression: sql`CASE WHEN ${expression} IS NULL THEN ${sql.lit(nullRank)} ELSE ${sql.lit(valueRank)} END`
+        };
+    }
+    readAccessPredicate(params, modelID) {
+        const { viewerDID, groupIDs, circleIDs, serverDefault } = params;
+        const docRestrictedParts = [
+            sql`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedDIDs'), '[]')) WHERE value = ${viewerDID})`
+        ];
+        if (groupIDs.length > 0) {
+            docRestrictedParts.push(sql`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedGroups'), '[]')) WHERE value IN (${sql.join(groupIDs.map((id)=>sql`${id}`))}))`);
+        }
+        if (circleIDs.length > 0) {
+            docRestrictedParts.push(sql`EXISTS (SELECT 1 FROM json_each(COALESCE(json_extract(data, '$.accessPermissions.read.allowedCircles'), '[]')) WHERE value IN (${sql.join(circleIDs.map((id)=>sql`${id}`))}))`);
+        }
+        const docRestricted = docRestrictedParts.reduce((a, b)=>sql`${a} OR ${b}`);
+        const madRestrictedParts = [
+            sql`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_dids, '[]')) WHERE value = ${viewerDID})`
+        ];
+        if (groupIDs.length > 0) {
+            madRestrictedParts.push(sql`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_groups, '[]')) WHERE value IN (${sql.join(groupIDs.map((id)=>sql`${id}`))}))`);
+        }
+        if (circleIDs.length > 0) {
+            madRestrictedParts.push(sql`EXISTS (SELECT 1 FROM json_each(COALESCE(_mad.allowed_circles, '[]')) WHERE value IN (${sql.join(circleIDs.map((id)=>sql`${id}`))}))`);
+        }
+        const madRestricted = madRestrictedParts.reduce((a, b)=>sql`${a} OR ${b}`);
+        const serverDefaultCond = serverDefault === 'anyone' ? sql`1 = 1` : serverDefault === 'only_owner' ? sql`owner = ${viewerDID}` : sql`1 = 0`;
+        return sql`(
+      owner = ${viewerDID}
       OR json_extract(data, '$.accessPermissions.read.level') = 'anyone'
-      OR (json_extract(data, '$.accessPermissions.read.level') = 'only_owner' AND owner = ${t})
-      OR (json_extract(data, '$.accessPermissions.read.level') = 'restricted' AND (${c}))
+      OR (json_extract(data, '$.accessPermissions.read.level') = 'only_owner' AND owner = ${viewerDID})
+      OR (json_extract(data, '$.accessPermissions.read.level') = 'restricted' AND (${docRestricted}))
       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 = ${s} AND _mad.permission_type = 'read'
+        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 = ${t})
-          OR (_mad.access_level = 'restricted' AND (${i}))
+          OR (_mad.access_level = 'only_owner' AND owner = ${viewerDID})
+          OR (_mad.access_level = 'restricted' AND (${madRestricted}))
         )
       ))
       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 = ${s} AND _mad2.permission_type = 'read'
-      ) AND (${l}))
-    )`}async createSearchIndex(a,s){let t=`fts_${s.modelID}`,r=["document_id UNINDEXED",...s.fields].join(", ");await e`CREATE VIRTUAL TABLE IF NOT EXISTS ${e.ref(t)} USING fts5(${e.raw(r)})`.execute(a)}async dropSearchIndex(a,s){let t=`fts_${s}`;await e`DROP TABLE IF EXISTS ${e.ref(t)}`.execute(a)}async updateSearchEntry(a,s,t,r,n){let o=`fts_${s}`;await e`DELETE FROM ${e.ref(o)} WHERE document_id = ${t}`.execute(a);let d=["document_id",...n].join(", "),c=[t,...n.map(e=>r[e]??"")].map(a=>e.lit(a));await e`INSERT INTO ${e.ref(o)} (${e.raw(d)}) VALUES (${e.join(c)})`.execute(a)}async removeSearchEntry(a,s,t){let r=`fts_${s}`;await e`DELETE FROM ${e.ref(r)} WHERE document_id = ${t}`.execute(a)}async searchIndex(a,s){let t=`fts_${s.modelID}`;return(await e`
-      SELECT document_id, rank FROM ${e.ref(t)}
-      WHERE ${e.ref(t)} MATCH ${s.query}
+        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}))
+    )`;
+    }
+    async createSearchIndex(db, config) {
+        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);
+    }
+    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) {
+        const tableName = `fts_${modelID}`;
+        await sql`DELETE FROM ${sql.ref(tableName)} WHERE document_id = ${documentID}`.execute(db);
+        const columns = [
+            'document_id',
+            ...fieldNames
+        ].join(', ');
+        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);
+    }
+    async removeSearchEntry(db, modelID, documentID) {
+        const tableName = `fts_${modelID}`;
+        await sql`DELETE FROM ${sql.ref(tableName)} WHERE document_id = ${documentID}`.execute(db);
+    }
+    async searchIndex(db, params) {
+        const tableName = `fts_${params.modelID}`;
+        const results = await sql`
+      SELECT document_id, rank FROM ${sql.ref(tableName)}
+      WHERE ${sql.ref(tableName)} MATCH ${params.query}
       ORDER BY rank
-      LIMIT ${s.limit}
-    `.execute(a)).rows.map(e=>({documentID:e.document_id,rank:e.rank}))}}
+      LIMIT ${params.limit}
+    `.execute(db);
+        return results.rows.map((row)=>({
+                documentID: row.document_id,
+                rank: row.rank
+            }));
+    }
+}

package/lib/types.d.ts

@@ -1,7 +1,15 @@
 import type { ColumnDataType, ColumnType, Dialect, Expression, Kysely, RawBuilder } from 'kysely';
+export type OrderDirection = 'asc' | 'desc';
+export type NullOrderingTerm = {
+    kind: 'lead';
+    expression: Expression<number>;
+} | {
+    kind: 'native';
+};
 export type CreatedAtColumn = ColumnType<number, number | undefined, never>;
 export type UpdatedAtColumn = ColumnType<number, number | undefined, number | undefined>;
 export type ColumnTypes = {
+    bigint: ColumnDataType;
     binary: ColumnDataType;
     json: ColumnDataType;
     serial: ColumnDataType;
@@ -44,6 +52,7 @@ export type AbstractAdapter<T extends AdapterTypes = AdapterTypes> = {
     searchIndex(db: Kysely<unknown>, params: SearchQuery): Promise<Array<SearchHit>>;
     coerceFilterValue(value: unknown): unknown;
     numericCast(expression: Expression<unknown>): Expression<number>;
+    nullOrdering(expression: Expression<unknown>, direction: OrderDirection): NullOrderingTerm;
     readAccessPredicate(params: {
         viewerDID: string;
         groupIDs: Array<string>;

package/lib/types.js

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

package/package.json

@@ -1,30 +1,30 @@
 {
   "name": "@kubun/db-adapter",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.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.4"
   },
   "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 ../../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",
+    "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"
   }
 }