@undefineds.co/xpod 0.3.74 → 0.4.0-rc.139

package/dist/storage/rdf/RdfVectorIndex.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RdfVectorIndex = void 0;
+exports.RdfVectorIndex = exports.RDF_VECTOR_SCHEMA_VERSION = void 0;
 exports.vectorScoreComponents = vectorScoreComponents;
 exports.normalizeEmbedding = normalizeEmbedding;
 exports.parseEmbedding = parseEmbedding;
@@ -17,10 +17,22 @@ exports.vectorSquaredDistanceSql = vectorSquaredDistanceSql;
 exports.vectorThresholdSql = vectorThresholdSql;
 exports.applyResultWindow = applyResultWindow;
 exports.sqlNumber = sqlNumber;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const SqliteRuntime_1 = require("../SqliteRuntime");
 const RdfSearchSourceFilter_1 = require("./RdfSearchSourceFilter");
+const RdfSqliteConnection_1 = require("./RdfSqliteConnection");
+exports.RDF_VECTOR_SCHEMA_VERSION = 2;
+const RDF_VECTOR_DOMAIN_TABLES = [
+    'rdf_vector_metadata',
+    'rdf_vector_sources',
+    'rdf_vector_chunks',
+    'rdf_vector_components',
+];
+const RDF_VECTOR_REQUIRED_COLUMNS = {
+    rdf_vector_metadata: ['key', 'value'],
+    rdf_vector_sources: ['id', 'source_key', 'source', 'workspace', 'local_path', 'content_type', 'source_version', 'source_hash', 'updated_at'],
+    rdf_vector_chunks: ['id', 'source_id', 'chunk_key', 'ordinal', 'level', 'heading', 'path', 'content', 'start_offset', 'end_offset', 'embedding_json', 'summary_metadata', 'dimensions', 'magnitude', 'provider', 'model', 'model_version', 'input_kind', 'input_hash', 'projection_policy_version', 'updated_at'],
+    rdf_vector_components: ['chunk_id', 'dimension', 'value', 'updated_at'],
+};
 class RdfVectorIndex {
     constructor(options) {
         this.options = options;
@@ -31,13 +43,7 @@ class RdfVectorIndex {
         if (this.db) {
             return;
         }
-        if (this.options.path !== ':memory:') {
-            const dir = (0, node_path_1.dirname)(this.options.path);
-            if (!(0, node_fs_1.existsSync)(dir)) {
-                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-            }
-        }
-        this.db = this.sqliteRuntime.openDatabase(this.options.path);
+        this.db = (0, RdfSqliteConnection_1.openRdfSqliteDatabase)(this.sqliteRuntime, this.options.path);
         this.initializeSchema();
     }
     close() {
@@ -47,9 +53,14 @@ class RdfVectorIndex {
     clear() {
         this.requireDb().exec('DELETE FROM rdf_vector_components; DELETE FROM rdf_vector_chunks; DELETE FROM rdf_vector_sources;');
     }
+    schemaVersion() {
+        const row = this.requireDb()
+            .prepare("SELECT value FROM rdf_vector_metadata WHERE key = 'schema_version'")
+            .get();
+        return Number(row?.value ?? 0) || 0;
+    }
     indexVector(source, chunks) {
         const db = this.requireDb();
-        const sourceId = this.upsertSource(source);
         const insertChunk = db.prepare(`
       INSERT INTO rdf_vector_chunks (
         source_id,
@@ -85,6 +96,7 @@ class RdfVectorIndex {
       VALUES (?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     `);
         db.transaction(() => {
+            const sourceId = this.upsertSource(source);
             if (chunks.length === 0) {
                 db.prepare(`
           DELETE FROM rdf_vector_components
@@ -149,6 +161,49 @@ class RdfVectorIndex {
             return deletedChunks;
         })();
     }
+    moveSource(oldSource, next) {
+        const db = this.requireDb();
+        let affectedRows = 0;
+        db.transaction(() => {
+            const oldRow = db.prepare('SELECT * FROM rdf_vector_sources WHERE source = ?').get(oldSource);
+            if (!oldRow) {
+                return;
+            }
+            const sourceKey = oldRow.source_key;
+            if (next.sourceKey && next.sourceKey !== sourceKey) {
+                throw new Error(`RDF vector source key mismatch for source ${oldSource}: expected ${sourceKey}, got ${next.sourceKey}`);
+            }
+            const chunkCount = db
+                .prepare('SELECT COUNT(*) AS count FROM rdf_vector_chunks WHERE source_id = ?')
+                .get(oldRow.id)?.count ?? 0;
+            const targetRow = db.prepare('SELECT * FROM rdf_vector_sources WHERE source = ?').get(next.source);
+            if (targetRow && targetRow.id !== oldRow.id) {
+                db.prepare(`
+          DELETE FROM rdf_vector_components
+          WHERE chunk_id IN (
+            SELECT id FROM rdf_vector_chunks WHERE source_id = ?
+          )
+        `).run(targetRow.id);
+                db.prepare('DELETE FROM rdf_vector_chunks WHERE source_id = ?').run(targetRow.id);
+                db.prepare('DELETE FROM rdf_vector_sources WHERE id = ?').run(targetRow.id);
+            }
+            db.prepare(`
+        UPDATE rdf_vector_sources
+        SET
+          source_key = ?,
+          source = ?,
+          workspace = ?,
+          local_path = ?,
+          content_type = ?,
+          source_version = ?,
+          source_hash = ?,
+          updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+        WHERE id = ?
+      `).run(sourceKey, next.source, next.workspace, next.localPath ?? null, next.contentType ?? null, next.sourceVersion ?? null, next.sourceHash ?? oldRow.source_hash ?? null, oldRow.id);
+            affectedRows = Math.max(chunkCount, 1);
+        })();
+        return affectedRows;
+    }
     search(options) {
         const embedding = normalizeEmbedding(options.embedding);
         if (embedding.length === 0) {
@@ -311,10 +366,20 @@ class RdfVectorIndex {
         }));
     }
     initializeSchema() {
-        this.requireDb().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_vector_sources (
+        const db = this.requireDb();
+        if (hasAnyTable(db, RDF_VECTOR_DOMAIN_TABLES)) {
+            this.validateSchema();
+            return;
+        }
+        db.exec(`
+      CREATE TABLE rdf_vector_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE rdf_vector_sources (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_key TEXT,
+        source_key TEXT NOT NULL UNIQUE,
         source TEXT NOT NULL UNIQUE,
         workspace TEXT NOT NULL,
         local_path TEXT,
@@ -324,7 +389,7 @@ class RdfVectorIndex {
         updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_vector_chunks (
+      CREATE TABLE rdf_vector_chunks (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         source_id INTEGER NOT NULL,
         chunk_key TEXT NOT NULL,
@@ -359,7 +424,7 @@ class RdfVectorIndex {
         FOREIGN KEY (source_id) REFERENCES rdf_vector_sources(id)
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_vector_components (
+      CREATE TABLE rdf_vector_components (
         chunk_id INTEGER NOT NULL,
         dimension INTEGER NOT NULL,
         value REAL NOT NULL,
@@ -372,213 +437,35 @@ class RdfVectorIndex {
       CREATE INDEX IF NOT EXISTS rdf_vector_sources_source ON rdf_vector_sources(source);
       CREATE INDEX IF NOT EXISTS rdf_vector_chunks_source ON rdf_vector_chunks(source_id, ordinal);
       CREATE INDEX IF NOT EXISTS rdf_vector_components_dimension ON rdf_vector_components(dimension, chunk_id);
-    `);
-        this.ensureSourceKeyColumn();
-        this.ensureVectorIdentityColumns();
-        this.backfillVectorComponents();
-    }
-    ensureSourceKeyColumn() {
-        const db = this.requireDb();
-        const columns = db.prepare('PRAGMA table_info(rdf_vector_sources)').all();
-        if (!columns.some((column) => column.name === 'source_key')) {
-            db.exec('ALTER TABLE rdf_vector_sources ADD COLUMN source_key TEXT');
-        }
-        db.exec('UPDATE rdf_vector_sources SET source_key = source WHERE source_key IS NULL OR source_key = \'\';');
-    }
-    ensureVectorIdentityColumns() {
-        const db = this.requireDb();
-        const columns = db.prepare('PRAGMA table_info(rdf_vector_chunks)').all();
-        const names = new Set(columns.map((column) => column.name));
-        for (const [name, definition] of [
-            ['provider', 'TEXT NOT NULL DEFAULT \'\''],
-            ['model_version', 'TEXT NOT NULL DEFAULT \'\''],
-            ['input_kind', 'TEXT NOT NULL DEFAULT \'\''],
-            ['input_hash', 'TEXT NOT NULL DEFAULT \'\''],
-            ['projection_policy_version', 'TEXT NOT NULL DEFAULT \'\''],
-            ['summary_metadata', 'TEXT'],
-        ]) {
-            if (!names.has(name)) {
-                db.exec(`ALTER TABLE rdf_vector_chunks ADD COLUMN ${name} ${definition}`);
-            }
-        }
-        db.exec(`
-      UPDATE rdf_vector_chunks
-      SET
-        provider = COALESCE(provider, ''),
-        model_version = COALESCE(model_version, ''),
-        input_kind = COALESCE(input_kind, ''),
-        input_hash = COALESCE(input_hash, ''),
-        projection_policy_version = COALESCE(projection_policy_version, '')
-    `);
-        this.ensureVectorChunkIdentityUniqueConstraint();
-        db.exec(`
       CREATE INDEX IF NOT EXISTS rdf_vector_chunks_model_dimensions
-      ON rdf_vector_chunks(provider, model, model_version, input_kind, projection_policy_version, dimensions)
+      ON rdf_vector_chunks(provider, model, model_version, input_kind, projection_policy_version, dimensions);
+
+      INSERT INTO rdf_vector_metadata (key, value)
+      VALUES ('schema_version', '${exports.RDF_VECTOR_SCHEMA_VERSION}');
     `);
     }
-    ensureVectorChunkIdentityUniqueConstraint() {
+    validateSchema() {
         const db = this.requireDb();
-        const indexes = db.prepare('PRAGMA index_list(rdf_vector_chunks)').all();
-        const hasLegacyUnique = indexes.some((index) => {
-            if (!index.unique) {
-                return false;
+        for (const table of RDF_VECTOR_DOMAIN_TABLES) {
+            if (!hasTable(db, table)) {
+                throw new Error(`Unsupported RDF vector index schema: missing table ${table}`);
             }
-            const columns = db.prepare(`PRAGMA index_info(${sqliteStringLiteral(index.name)})`).all();
-            return columns.map((column) => column.name).join(',') === 'source_id,chunk_key';
-        });
-        if (!hasLegacyUnique) {
-            return;
+            assertRequiredColumns(db, table, RDF_VECTOR_REQUIRED_COLUMNS[table]);
         }
-        db.exec(`
-      ALTER TABLE rdf_vector_components RENAME TO rdf_vector_components_legacy_unique;
-      ALTER TABLE rdf_vector_chunks RENAME TO rdf_vector_chunks_legacy_unique;
-
-      CREATE TABLE rdf_vector_chunks (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        source_id INTEGER NOT NULL,
-        chunk_key TEXT NOT NULL,
-        ordinal INTEGER NOT NULL,
-        level INTEGER NOT NULL,
-        heading TEXT,
-        path TEXT,
-        content TEXT NOT NULL,
-        start_offset INTEGER NOT NULL,
-        end_offset INTEGER NOT NULL,
-        embedding_json TEXT NOT NULL,
-        summary_metadata TEXT,
-        dimensions INTEGER NOT NULL,
-        magnitude REAL NOT NULL,
-        provider TEXT NOT NULL DEFAULT '',
-        model TEXT NOT NULL,
-        model_version TEXT NOT NULL DEFAULT '',
-        input_kind TEXT NOT NULL DEFAULT '',
-        input_hash TEXT NOT NULL DEFAULT '',
-        projection_policy_version TEXT NOT NULL DEFAULT '',
-        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        UNIQUE (
-          source_id,
-          chunk_key,
-          provider,
-          model,
-          model_version,
-          input_kind,
-          projection_policy_version,
-          input_hash
-        ),
-        FOREIGN KEY (source_id) REFERENCES rdf_vector_sources(id)
-      );
-
-      CREATE TABLE rdf_vector_components (
-        chunk_id INTEGER NOT NULL,
-        dimension INTEGER NOT NULL,
-        value REAL NOT NULL,
-        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-        PRIMARY KEY (chunk_id, dimension),
-        FOREIGN KEY (chunk_id) REFERENCES rdf_vector_chunks(id)
-      );
-
-      INSERT INTO rdf_vector_chunks (
-        id,
-        source_id,
-        chunk_key,
-        ordinal,
-        level,
-        heading,
-        path,
-        content,
-        start_offset,
-        end_offset,
-        embedding_json,
-        summary_metadata,
-        dimensions,
-        magnitude,
-        provider,
-        model,
-        model_version,
-        input_kind,
-        input_hash,
-        projection_policy_version,
-        updated_at
-      )
-      SELECT
-        id,
-        source_id,
-        chunk_key,
-        ordinal,
-        level,
-        heading,
-        path,
-        content,
-        start_offset,
-        end_offset,
-        embedding_json,
-        NULL AS summary_metadata,
-        dimensions,
-        magnitude,
-        COALESCE(provider, ''),
-        model,
-        COALESCE(model_version, ''),
-        COALESCE(input_kind, ''),
-        COALESCE(input_hash, ''),
-        COALESCE(projection_policy_version, ''),
-        updated_at
-      FROM rdf_vector_chunks_legacy_unique;
-
-      INSERT INTO rdf_vector_components (
-        chunk_id,
-        dimension,
-        value,
-        updated_at
-      )
-      SELECT
-        chunk_id,
-        dimension,
-        value,
-        updated_at
-      FROM rdf_vector_components_legacy_unique;
-
-      DROP TABLE rdf_vector_components_legacy_unique;
-      DROP TABLE rdf_vector_chunks_legacy_unique;
-      CREATE INDEX IF NOT EXISTS rdf_vector_chunks_source ON rdf_vector_chunks(source_id, ordinal);
-      CREATE INDEX IF NOT EXISTS rdf_vector_components_dimension ON rdf_vector_components(dimension, chunk_id);
-    `);
-    }
-    backfillVectorComponents() {
-        const db = this.requireDb();
-        const rows = db.prepare(`
-      SELECT
-        chunk.id,
-        chunk.dimensions,
-        chunk.embedding_json,
-        COUNT(component.dimension) AS component_count
-      FROM rdf_vector_chunks chunk
-      LEFT JOIN rdf_vector_components component ON component.chunk_id = chunk.id
-      WHERE chunk.dimensions > 0
-      GROUP BY chunk.id
-      HAVING component_count <> chunk.dimensions
-    `).all();
-        if (rows.length === 0) {
-            return;
+        const version = this.schemaVersion();
+        if (version !== exports.RDF_VECTOR_SCHEMA_VERSION) {
+            throw new Error(`Unsupported RDF vector index schema version: expected ${exports.RDF_VECTOR_SCHEMA_VERSION}, got ${version}`);
         }
-        const deleteComponents = db.prepare('DELETE FROM rdf_vector_components WHERE chunk_id = ?');
-        const insertComponent = db.prepare(`
-      INSERT INTO rdf_vector_components (
-        chunk_id,
-        dimension,
-        value,
-        updated_at
-      )
-      VALUES (?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    `);
-        db.transaction(() => {
-            for (const row of rows) {
-                deleteComponents.run(row.id);
-                insertVectorComponents(insertComponent, row.id, parseEmbedding(row.embedding_json));
-            }
-        })();
+        assertNotNullColumn(db, 'rdf_vector_sources', 'source_key');
+        assertUniqueColumn(db, 'rdf_vector_sources', 'source_key');
     }
     upsertSource(source) {
         const db = this.requireDb();
+        const existing = db.prepare('SELECT * FROM rdf_vector_sources WHERE source = ?').get(source.source);
+        if (existing && source.sourceKey && existing.source_key !== source.sourceKey) {
+            throw new Error(`RDF vector source key mismatch for source ${source.source}: expected ${existing.source_key}, got ${source.sourceKey}`);
+        }
+        const sourceKey = existing?.source_key ?? source.sourceKey ?? source.source;
         db.prepare(`
       INSERT INTO rdf_vector_sources (
         source_key,
@@ -593,14 +480,13 @@ class RdfVectorIndex {
       VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
       ON CONFLICT (source)
       DO UPDATE SET
-        source_key = COALESCE(excluded.source_key, rdf_vector_sources.source_key, excluded.source),
         workspace = excluded.workspace,
         local_path = excluded.local_path,
         content_type = excluded.content_type,
         source_version = excluded.source_version,
         source_hash = excluded.source_hash,
         updated_at = excluded.updated_at
-    `).run(source.sourceKey ?? source.source, source.source, source.workspace, source.localPath ?? null, source.contentType ?? null, source.sourceVersion ?? null, source.sourceHash ?? null);
+    `).run(sourceKey, source.source, source.workspace, source.localPath ?? null, source.contentType ?? null, source.sourceVersion ?? null, source.sourceHash ?? null);
         const row = db.prepare('SELECT * FROM rdf_vector_sources WHERE source = ?').get(source.source);
         if (!row) {
             throw new Error(`Failed to upsert RDF vector source: ${source.source}`);
@@ -657,6 +543,24 @@ class RdfVectorIndex {
     }
 }
 exports.RdfVectorIndex = RdfVectorIndex;
+function normalizeVectorIdentity(chunk) {
+    return {
+        provider: chunk.provider ?? '',
+        model: chunk.model ?? '',
+        modelVersion: chunk.modelVersion ?? '',
+        inputKind: chunk.inputKind ?? '',
+        projectionPolicyVersion: chunk.projectionPolicyVersion ?? '',
+    };
+}
+function vectorIdentityKey(identity) {
+    return [
+        identity.provider,
+        identity.model,
+        identity.modelVersion,
+        identity.inputKind,
+        identity.projectionPolicyVersion,
+    ].join('\u0000');
+}
 function vectorScoreComponents(row, metric, queryMagnitude, score, distance, backend) {
     const distanceSquared = row.vector_distance_squared ?? undefined;
     return {
@@ -759,26 +663,45 @@ function parseSummaryMetadata(value) {
         return undefined;
     }
 }
-function normalizeVectorIdentity(chunk) {
-    return {
-        provider: chunk.provider ?? '',
-        model: chunk.model ?? '',
-        modelVersion: chunk.modelVersion ?? '',
-        inputKind: chunk.inputKind ?? '',
-        projectionPolicyVersion: chunk.projectionPolicyVersion ?? '',
-    };
+function hasAnyTable(db, tables) {
+    return tables.some((table) => hasTable(db, table));
 }
-function vectorIdentityKey(identity) {
-    return [
-        identity.provider,
-        identity.model,
-        identity.modelVersion,
-        identity.inputKind,
-        identity.projectionPolicyVersion,
-    ].join('\u0000');
+function hasTable(db, table) {
+    return db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table) != null;
+}
+function assertRequiredColumns(db, table, requiredColumns) {
+    const columns = new Set(db.prepare(`PRAGMA table_info(${table})`)
+        .all()
+        .map((column) => column.name));
+    for (const column of requiredColumns) {
+        if (!columns.has(column)) {
+            throw new Error(`Unsupported RDF vector index schema: missing column ${table}.${column}`);
+        }
+    }
+}
+function assertNotNullColumn(db, table, column) {
+    const row = db.prepare(`PRAGMA table_info(${quoteSqliteIdentifier(table)})`)
+        .all()
+        .find((entry) => entry.name === column);
+    if (!row || row.notnull !== 1) {
+        throw new Error(`Unsupported RDF vector index schema: column ${table}.${column} must be NOT NULL`);
+    }
+}
+function assertUniqueColumn(db, table, column) {
+    const indexes = db.prepare(`PRAGMA index_list(${quoteSqliteIdentifier(table)})`).all();
+    for (const index of indexes) {
+        if (index.unique !== 1) {
+            continue;
+        }
+        const columns = db.prepare(`PRAGMA index_info(${quoteSqliteIdentifier(index.name)})`).all();
+        if (columns.length === 1 && columns[0].name === column) {
+            return;
+        }
+    }
+    throw new Error(`Unsupported RDF vector index schema: column ${table}.${column} must be UNIQUE`);
 }
-function sqliteStringLiteral(value) {
-    return `'${value.replace(/'/g, '\'\'')}'`;
+function quoteSqliteIdentifier(value) {
+    return `"${value.replace(/"/g, '""')}"`;
 }
 function appendVectorIdentityFilters(options, conditions, params) {
     if (options.provider !== undefined) {

package/dist/storage/rdf/RdfVectorIndex.jsonld

@@ -74,6 +74,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_clear",
           "memberFieldName": "clear"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_schemaVersion",
+          "memberFieldName": "schemaVersion"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_indexVector",
           "memberFieldName": "indexVector"
@@ -82,6 +86,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_deleteSource",
           "memberFieldName": "deleteSource"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_moveSource",
+          "memberFieldName": "moveSource"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_search",
           "memberFieldName": "search"
@@ -107,20 +115,8 @@
           "memberFieldName": "initializeSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_ensureSourceKeyColumn",
-          "memberFieldName": "ensureSourceKeyColumn"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_ensureVectorIdentityColumns",
-          "memberFieldName": "ensureVectorIdentityColumns"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_ensureVectorChunkIdentityUniqueConstraint",
-          "memberFieldName": "ensureVectorChunkIdentityUniqueConstraint"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_backfillVectorComponents",
-          "memberFieldName": "backfillVectorComponents"
+          "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_validateSchema",
+          "memberFieldName": "validateSchema"
         },
         {
           "@id": "undefineds:dist/storage/rdf/RdfVectorIndex.jsonld#RdfVectorIndex__member_upsertSource",

package/dist/storage/rdf/SolidRdfEngine.d.ts

@@ -1,36 +1,32 @@
 import type { Quad } from '@rdfjs/types';
-import type { QuintPattern, QuintStore } from '../quint/types';
-import type { Rdf3xShadowJoinResult, Rdf3xShadowScanResult, Rdf3xIndexOptions, RdfDerivedIndexProfile, RdfDerivedIndexRefreshOptions, RdfDerivedIndexRefreshResult, RdfEngineStorageStats, RdfIndexPutOptions, RdfPatternQuery, RdfQuadJoinOptions, RdfQuadJoinPattern, RdfQuadIndexOptions, RdfQuadIndexScanResult, RdfSourceInput, RdfShadowScanResult, RdfTextChunkInput, RdfTextIndexOptions, RdfTextIndexSyncLike, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfVectorChunkInput, RdfVectorIndexOptions, RdfVectorIndexSyncLike, RdfVectorSearchOptions, RdfVectorSearchResult, RdfVectorSourceInput, RdfEngineLike, RdfStorageStatsOptions } from './types';
+import type { QuintPattern } from '../quint/types';
+import type { RdfDerivedIndexRefreshOptions, RdfDerivedIndexRefreshResult, RdfEngineStorageStats, RdfIndexPutOptions, RdfPatternQuery, RdfQuadIndexOptions, RdfQuadIndexScanResult, RdfSourceInput, RdfTextChunkInput, RdfTextIndexOptions, RdfTextIndexSyncLike, RdfTextSourceListOptions, RdfTextSourceMetadata, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfVectorChunkInput, RdfVectorIndexOptions, RdfVectorIndexSyncLike, RdfVectorSearchOptions, RdfVectorSearchResult, RdfVectorSourceInput, RdfEngineLike, RdfNativeSparqlQueryOptions, RdfNativeSparqlResult, RdfStorageStatsOptions } from './types';
 import { RdfQuadIndex } from './RdfQuadIndex';
-import { Rdf3xIndex } from './Rdf3xIndex';
 import type { RdfQuery, RdfQueryResult } from './types';
 type RdfTextIndexInput = RdfTextIndexSyncLike | RdfTextIndexOptions;
 type RdfVectorIndexInput = RdfVectorIndexSyncLike | RdfVectorIndexOptions;
+export interface LocalNativeSparqlClientLike {
+    start(): void | Promise<void>;
+    query(query: string, options: RdfNativeSparqlQueryOptions): RdfNativeSparqlResult | Promise<RdfNativeSparqlResult>;
+    close(): void | Promise<void>;
+}
 export interface SolidRdfEngineOptions {
     index: RdfQuadIndex | RdfQuadIndexOptions;
-    derivedIndexProfile?: RdfDerivedIndexProfile;
     textIndex?: RdfTextIndexInput;
     vectorIndex?: RdfVectorIndexInput;
-    rdf3xIndex?: Rdf3xIndex | Rdf3xIndexOptions;
-    rdf3xPrimary?: boolean;
-    compatibilityStore?: QuintStore;
+    nativeSparqlClient?: LocalNativeSparqlClientLike;
     autoOpen?: boolean;
 }
 export declare class SolidRdfEngine implements RdfEngineLike {
     readonly index: RdfQuadIndex;
     readonly textIndex?: RdfTextIndexSyncLike;
     readonly vectorIndex?: RdfVectorIndexSyncLike;
-    readonly rdf3xIndex?: Rdf3xIndex;
-    readonly derivedIndexProfile: RdfDerivedIndexProfile;
     private readonly ownsIndex;
     private readonly ownsTextIndex;
     private readonly ownsVectorIndex;
-    private readonly ownsRdf3xIndex;
-    private readonly rdf3xPrimary;
-    private readonly compatibilityStore?;
-    private shadowComparator?;
+    private readonly nativeSparqlClient?;
     constructor(options: SolidRdfEngineOptions);
-    open(): void;
+    open(): Promise<void>;
     close(): Promise<void>;
     put(quads: Quad | Quad[], options?: RdfIndexPutOptions): void;
     replaceSource(quads: Quad[], source: RdfSourceInput): void;
@@ -44,22 +40,21 @@ export declare class SolidRdfEngine implements RdfEngineLike {
     rewriteTerms(input: RdfTermRewriteInput): RdfTermRewriteResult;
     scan(query: RdfPatternQuery): RdfQuadIndexScanResult;
     query(query: RdfQuery): RdfQueryResult;
-    refreshDerivedIndexes(options?: RdfDerivedIndexRefreshOptions): RdfDerivedIndexRefreshResult;
+    sparqlQuery(query: string, options: RdfNativeSparqlQueryOptions): Promise<RdfNativeSparqlResult>;
+    refreshDerivedIndexes(_options?: RdfDerivedIndexRefreshOptions): RdfDerivedIndexRefreshResult;
     indexTextSource(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): void;
     deleteTextSource(source: string): number;
+    moveTextSource(oldSource: string, next: RdfTextSourceInput): number;
+    listTextSources(options?: RdfTextSourceListOptions): RdfTextSourceMetadata[];
     searchText(options: RdfTextSearchOptions | string): RdfTextSearchResult[];
+    listTextSourceChunks(sourceKey: string): RdfTextSearchResult[];
     indexVectorSource(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): void;
     deleteVectorSource(source: string): number;
+    moveVectorSource(oldSource: string, next: RdfVectorSourceInput): number;
     searchVector(options: RdfVectorSearchOptions): RdfVectorSearchResult[];
-    shadowScan(query: RdfPatternQuery): Promise<RdfShadowScanResult>;
-    shadowRdf3xScan(query: RdfPatternQuery): Rdf3xShadowScanResult;
-    shadowRdf3xJoin(patterns: RdfQuadJoinPattern[], options?: RdfQuadJoinOptions): Rdf3xShadowJoinResult;
     supportsPrimary(query: RdfPatternQuery): boolean;
     storageStats(_options?: RdfStorageStatsOptions): RdfEngineStorageStats;
     private requireTextIndex;
     private requireVectorIndex;
-    private requireRdf3xIndex;
-    private isRdf3xPrimaryReady;
-    private refreshRdf3xDerivedIndex;
 }
 export {};