@kubun/db-adapter 0.9.0 → 0.11.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 { Kysely } from 'kysely';
-import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
+import type { Expression, Kysely, RawBuilder } from 'kysely';
+import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
 export type PostgresTypes = {
     Binary: Uint8Array;
     JSON: unknown;
@@ -13,6 +13,14 @@ export declare class AbstractPostgresAdapter<T extends AdapterTypes = PostgresTy
     encodeTimestamp(value: Date): string;
     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>;
+        circleIDs: Array<string>;
+        serverDefault: string;
+    }, modelID: string): RawBuilder<boolean>;
     createSearchIndex(db: Kysely<unknown>, config: SearchIndexConfig): Promise<void>;
     dropSearchIndex(db: Kysely<unknown>, modelID: string): Promise<void>;
     updateSearchEntry(db: Kysely<unknown>, modelID: string, documentID: string, fields: Record<string, string>, fieldNames: Array<string>): Promise<void>;

package/lib/postgres.js

@@ -1,19 +1,136 @@
-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}async createSearchIndex(t,r){let a=`fts_${r.modelID}`,c=`k_${r.modelID}`;await e`
-      CREATE TABLE IF NOT EXISTS ${e.ref(a)} (
-        document_id TEXT PRIMARY KEY REFERENCES ${e.ref(c)}(id) ON DELETE CASCADE,
+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 = ${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 = ${modelID} AND _mad.permission_type = 'read'
+        AND (
+          _mad.access_level = 'anyone'
+          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 = ${modelID} AND _mad2.permission_type = 'read'
+      ) 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_${r.modelID}`)}
-      ON ${e.ref(a)} USING GIN(search_vector)
-    `.execute(t)}async dropSearchIndex(t,r){let a=`fts_${r}`;await e`DROP TABLE IF EXISTS ${e.ref(a)} CASCADE`.execute(t)}async updateSearchEntry(t,r,a,c,n){let s=`fts_${r}`,o=n.map(t=>{let r=c[t]??"";return e`to_tsvector('simple', ${r})`}).reduce((t,r)=>e`${t} || ${r}`);await e`
-      INSERT INTO ${e.ref(s)} (document_id, search_vector)
-      VALUES (${a}, ${o})
-      ON CONFLICT (document_id) DO UPDATE SET search_vector = ${o}
-    `.execute(t)}async removeSearchEntry(t,r,a){let c=`fts_${r}`;await e`DELETE FROM ${e.ref(c)} WHERE document_id = ${a}`.execute(t)}async searchIndex(t,r){let a=`fts_${r.modelID}`;return(await e`
-      SELECT document_id, ts_rank(search_vector, plainto_tsquery('simple', ${r.query})) AS rank
-      FROM ${e.ref(a)}
-      WHERE search_vector @@ plainto_tsquery('simple', ${r.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 ${r.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 { Kysely } from 'kysely';
-import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
+import type { Expression, Kysely, RawBuilder } from 'kysely';
+import type { AbstractAdapter, AdapterTypes, ColumnTypes, Functions, NullOrderingTerm, OrderDirection, SearchHit, SearchIndexConfig, SearchQuery } from './types.js';
 export type SQLiteTypes = {
     Binary: Uint8Array;
     JSON: string;
@@ -13,6 +13,14 @@ export declare class AbstractSQLiteAdapter<T extends AdapterTypes = SQLiteTypes>
     encodeTimestamp(value: Date): number;
     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>;
+        circleIDs: Array<string>;
+        serverDefault: string;
+    }, modelID: string): RawBuilder<boolean>;
     createSearchIndex(db: Kysely<unknown>, config: SearchIndexConfig): Promise<void>;
     dropSearchIndex(db: Kysely<unknown>, modelID: string): Promise<void>;
     updateSearchEntry(db: Kysely<unknown>, modelID: string, documentID: string, fields: Record<string, string>, fieldNames: Array<string>): Promise<void>;

package/lib/sqlite.js

@@ -1,6 +1,133 @@
-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}async createSearchIndex(t,r){let a=`fts_${r.modelID}`,n=["document_id UNINDEXED",...r.fields].join(", ");await e`CREATE VIRTUAL TABLE IF NOT EXISTS ${e.ref(a)} USING fts5(${e.raw(n)})`.execute(t)}async dropSearchIndex(t,r){let a=`fts_${r}`;await e`DROP TABLE IF EXISTS ${e.ref(a)}`.execute(t)}async updateSearchEntry(t,r,a,n,i){let c=`fts_${r}`;await e`DELETE FROM ${e.ref(c)} WHERE document_id = ${a}`.execute(t);let o=["document_id",...i].join(", "),d=[a,...i.map(e=>n[e]??"")].map(t=>e.lit(t));await e`INSERT INTO ${e.ref(c)} (${e.raw(o)}) VALUES (${e.join(d)})`.execute(t)}async removeSearchEntry(t,r,a){let n=`fts_${r}`;await e`DELETE FROM ${e.ref(n)} WHERE document_id = ${a}`.execute(t)}async searchIndex(t,r){let a=`fts_${r.modelID}`;return(await e`
-      SELECT document_id, rank FROM ${e.ref(a)}
-      WHERE ${e.ref(a)} MATCH ${r.query}
+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 = ${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 = ${modelID} AND _mad.permission_type = 'read'
+        AND (
+          _mad.access_level = 'anyone'
+          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 = ${modelID} AND _mad2.permission_type = 'read'
+      ) 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 ${r.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/types.d.ts

@@ -1,7 +1,15 @@
-import type { ColumnDataType, ColumnType, Dialect, Kysely, RawBuilder } from 'kysely';
+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;
@@ -43,6 +51,14 @@ export type AbstractAdapter<T extends AdapterTypes = AdapterTypes> = {
     removeSearchEntry(db: Kysely<unknown>, modelID: string, documentID: string): Promise<void>;
     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>;
+        circleIDs: Array<string>;
+        serverDefault: string;
+    }, modelID: string): RawBuilder<boolean>;
 };
 export type Adapter<T extends AdapterTypes = AdapterTypes> = AbstractAdapter<T> & {
     dialect: Dialect;

package/lib/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/db-adapter",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,11 +15,11 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "kysely": "^0.28.17"
+    "kysely": "^0.29.2"
   },
   "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",