@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/rdf/PostgresRdfEngine.js

@@ -15,7 +15,7 @@ const RdfVectorIndex_1 = require("./RdfVectorIndex");
 const PostgresRdfTextIndex_1 = require("./PostgresRdfTextIndex");
 const PostgresRdfVectorIndex_1 = require("./PostgresRdfVectorIndex");
 const PostgresRdfStatisticsStore_1 = require("./PostgresRdfStatisticsStore");
-const RdfSparqlAdapter_1 = require("./RdfSparqlAdapter");
+const RdfSparqlBoundary_1 = require("./RdfSparqlBoundary");
 const types_1 = require("../quint/types");
 const { namedNode, quad } = n3_1.DataFactory;
 const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
@@ -1003,7 +1003,7 @@ class PostgresRdfEngine {
             ...options,
             driver: options.driver ?? (options.connectionString || options.pool ? 'pg' : 'pglite'),
         };
-        if (options.nativeSparqlEnabled) {
+        if (this.pgOptions.driver === 'pg' && this.pgOptions.nativeSparqlEnabled === true) {
             this.sparqlQuery = this.executeNativeSparql.bind(this);
         }
         this.maintenanceLeaseOwner = options.maintenanceLeaseOwner ?? `xpod-rdf-${process.pid}-${(0, node_crypto_1.randomUUID)()}`;
@@ -1080,19 +1080,9 @@ class PostgresRdfEngine {
                 await runPhase('schema', () => this.initializeSchema());
                 await this.initializeStatisticsStore();
                 this.pgAcceleration = await runPhase('acceleration-probe', () => this.probePgAcceleration());
-                await runPhase('native-sparql-probe', async () => {
-                    try {
-                        await this.probeNativeSparql();
-                    }
-                    catch (error) {
-                        if (this.pgOptions.nativeSparqlRequired !== false
-                            || !(error instanceof NativeSparqlUnavailableError)) {
-                            throw error;
-                        }
-                        this.sparqlQuery = undefined;
-                        this.logger.warn(`Optional native SPARQL unavailable; RDF3X remains active: ${errorMessage(error)}`);
-                    }
-                });
+                if (this.pgOptions.nativeSparqlEnabled === true) {
+                    await runPhase('native-sparql-probe', () => this.probeNativeSparql());
+                }
                 this.initialized = true;
                 await runPhase('maintenance-scheduler', async () => {
                     this.startMaintenanceScheduler();
@@ -1172,53 +1162,23 @@ class PostgresRdfEngine {
     }
     async executeNativeSparql(query, options) {
         await this.ensureReady();
-        const extensionOptions = {
-            graphPrefix: options.accessScope?.basePath ?? options.basePath,
-            authorizationModel: 'mixed',
+        const wireOptions = {
+            basePath: options.basePath,
+            ...(options.sourceUri === undefined ? {} : { sourceUri: options.sourceUri }),
+            ...(options.defaultDataset === undefined ? {} : { defaultDataset: options.defaultDataset }),
+            ...(options.operation === undefined ? {} : { operation: options.operation }),
+            ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            ...(options.acceptMediaType === undefined ? {} : { acceptMediaType: options.acceptMediaType }),
+            ...(options.loadDocument === undefined ? {} : { loadDocument: options.loadDocument }),
+            ...(options.accessScope === undefined ? {} : { accessScope: options.accessScope }),
+            ...(options.vectorQuery === undefined ? {} : { vectorQuery: options.vectorQuery }),
         };
-        if (options.operation) {
-            extensionOptions.operation = 'execute';
-        }
-        if (options.timeoutMs !== undefined) {
-            extensionOptions.timeoutMs = options.timeoutMs;
-        }
-        if (options.acceptMediaType) {
-            extensionOptions.acceptMediaType = options.acceptMediaType;
-        }
-        if (options.loadDocument) {
-            extensionOptions.loadDocumentSourceUri = options.loadDocument.sourceUri;
-            extensionOptions.loadDocumentBody = options.loadDocument.body;
-            if (options.loadDocument.mediaType) {
-                extensionOptions.loadDocumentMediaType = options.loadDocument.mediaType;
-            }
-        }
-        if (options.accessScope?.principal) {
-            extensionOptions.principal = options.accessScope.principal;
-        }
-        if (options.accessScope?.mode) {
-            extensionOptions.accessMode = options.accessScope.mode;
-        }
-        if (options.accessScope) {
-            extensionOptions.accessScopeResolved = true;
-        }
-        if (options.accessScope?.allowedGraphUrls) {
-            extensionOptions.allowedGraphUrls = options.accessScope.allowedGraphUrls;
-        }
-        if (options.accessScope?.deniedGraphUrls) {
-            extensionOptions.deniedGraphUrls = options.accessScope.deniedGraphUrls;
-        }
-        if (options.accessScope?.deniedGraphPrefixes) {
-            extensionOptions.deniedGraphPrefixes = options.accessScope.deniedGraphPrefixes;
-        }
-        if (options.accessScope?.version) {
-            extensionOptions.permissionVersion = options.accessScope.version;
-        }
         let rows;
         try {
-            rows = await this.requireExecutor().query('SELECT xpod_rdf.native_sparql_query($1, $2::jsonb) AS result', [query, JSON.stringify(extensionOptions)]);
+            rows = await this.requireExecutor().query('SELECT xpod_rdf.native_sparql_query($1, $2::jsonb) AS result', [query, JSON.stringify(wireOptions)]);
         }
         catch (error) {
-            throw new RdfSparqlAdapter_1.NativeSparqlExecutionError(errorMessage(error));
+            throw new RdfSparqlBoundary_1.NativeSparqlExecutionError(errorMessage(error));
         }
         const envelope = typeof rows[0]?.result === 'string'
             ? JSON.parse(rows[0].result)
@@ -1235,7 +1195,7 @@ class PostgresRdfEngine {
         return result;
     }
     async probeNativeSparql() {
-        if (!this.pgOptions.nativeSparqlEnabled) {
+        if (this.pgOptions.driver !== 'pg') {
             return;
         }
         let rows;
@@ -1367,11 +1327,13 @@ class PostgresRdfEngine {
         await this.ensureReady();
         const executor = this.requireExecutor();
         return await executor.transaction(async (tx) => {
+            const scopedDictionary = new PostgresRdfTermDictionary(tx);
             const sourceRows = await tx.query('SELECT * FROM rdf_sources WHERE source = $1', [oldSource]);
             const sourceRow = sourceRows[0];
             if (!sourceRow) {
                 return 0;
             }
+            await scopedDictionary.getOrCreate(namedNode(next.source));
             const affectedRows = await tx.query('SELECT COUNT(*) AS count FROM rdf_quads WHERE source_file_id = $1', [sourceRow.id]);
             const affectedQuads = Number(affectedRows[0]?.count ?? 0);
             const targetRows = await tx.query('SELECT * FROM rdf_sources WHERE source = $1', [next.source]);
@@ -1588,8 +1550,8 @@ class PostgresRdfEngine {
     async scan(query) {
         await this.ensureReady();
         return isPgSqlScanCompatiblePattern(query.pattern)
-            ? this.scanNative(query.pattern, query.options)
-            : this.scanPostFilter(query.pattern, query.options);
+            ? this.scanNative(query.pattern, query.options, query.pattern.sourceScope)
+            : this.scanPostFilter(query.pattern, query.options, query.pattern.sourceScope);
     }
     async indexTextSource(source, text, chunks) {
         await this.requireTextIndex().indexText(source, text, chunks);
@@ -1597,6 +1559,9 @@ class PostgresRdfEngine {
     async deleteTextSource(source) {
         return await this.requireTextIndex().deleteSource(source);
     }
+    async moveTextSource(oldSource, next) {
+        return await this.requireTextIndex().moveSource(oldSource, next);
+    }
     async searchText(options) {
         return await this.requireTextIndex().search(typeof options === 'string' ? { query: options } : options);
     }
@@ -1606,6 +1571,9 @@ class PostgresRdfEngine {
     async deleteVectorSource(source) {
         return await this.requireVectorIndex().deleteSource(source);
     }
+    async moveVectorSource(oldSource, next) {
+        return await this.requireVectorIndex().moveSource(oldSource, next);
+    }
     async searchVector(options) {
         return await this.requireVectorIndex().search(options);
     }
@@ -2877,7 +2845,7 @@ class PostgresRdfEngine {
             durationMs: Date.now() - start,
         };
     }
-    async scanNative(pattern, options) {
+    async scanNative(pattern, options, sourceScope) {
         const start = Date.now();
         const resolved = await this.resolvePattern(pattern);
         if (resolved.unresolved) {
@@ -2886,7 +2854,7 @@ class PostgresRdfEngine {
                 metrics: this.indexMetrics('none', 0, 0, start, [`unresolved ${resolved.unresolved}`]),
             };
         }
-        const compiled = this.compileScanSql(resolved, options);
+        const compiled = this.compileScanSql(resolved, options, sourceScope);
         const matchedRows = await this.scalarCount(compiled.countSql, compiled.countParams);
         const rows = await this.requireExecutor().query(compiled.sql, compiled.params);
         return {
@@ -2901,13 +2869,18 @@ class PostgresRdfEngine {
     nativeScanCanUseLimitEarlyStop(options) {
         return options?.limit !== undefined && (!options.order || options.order.length === 0);
     }
-    async scanPostFilter(pattern, options) {
+    async scanPostFilter(pattern, options, sourceScope) {
         const start = Date.now();
+        const conditions = [];
+        const joins = [];
+        const builder = new PgSqlBuilder();
+        this.appendPgFactSourceScope(sourceScope, 'q', joins, conditions, builder);
         const rows = await this.requireExecutor().query(`
-      SELECT graph_id, subject_id, predicate_id, object_id
-      FROM ${RDF_FACTS_TABLE}
-      ORDER BY graph_id, subject_id, predicate_id, object_id
-    `);
+      SELECT q.graph_id, q.subject_id, q.predicate_id, q.object_id
+      FROM ${RDF_FACTS_TABLE} q${joins.join('')}
+      ${conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''}
+      ORDER BY q.graph_id, q.subject_id, q.predicate_id, q.object_id
+    `, builder.snapshot());
         const rangedRows = this.filterRowsBySlotTermRanges(rows, options?.slotTermRanges);
         const quads = await this.rowsToQuads(rangedRows);
         const matched = quads.filter((value) => matchesQuadPattern(value, pattern));
@@ -2922,6 +2895,7 @@ class PostgresRdfEngine {
             metrics: this.indexMetrics('facts-post-filter', matched.length, page.length, start, [
                 'PostgresFactsScan',
                 'PostgresFactsPostFilter',
+                ...(joins.length > 0 ? ['PostgresFactsSourceScope'] : []),
                 ...this.slotTermRangePlanMarkers(options?.slotTermRanges),
                 ...(options?.order?.length ? [`PostgresFactsScanOrder(${describeScanOrder(options)})`] : []),
                 ...(options?.limit !== undefined || options?.offset !== undefined ? ['PostgresFactsScanLimit'] : []),
@@ -4331,6 +4305,9 @@ class PostgresRdfEngine {
                 allowedGraphUrls: options.template.cacheScope.allowedGraphUrls,
                 deniedGraphUrls: options.template.cacheScope.deniedGraphUrls,
                 deniedGraphPrefixes: options.template.cacheScope.deniedGraphPrefixes,
+                allowedSourceUrls: options.template.cacheScope.allowedSourceUrls,
+                deniedSourceUrls: options.template.cacheScope.deniedSourceUrls,
+                deniedSourcePrefixes: options.template.cacheScope.deniedSourcePrefixes,
             },
         };
         const accelerationExplain = {
@@ -4841,8 +4818,8 @@ class PostgresRdfEngine {
                 continue;
             }
             const scan = isPgSqlScanCompatiblePattern(compiled)
-                ? await this.scanNative(compiled)
-                : await this.scanPostFilter(compiled);
+                ? await this.scanNative(compiled, undefined, pattern.sourceScope)
+                : await this.scanPostFilter(compiled, undefined, pattern.sourceScope);
             metrics.scannedRows += scan.metrics.matchedRows;
             metrics.indexChoices.push(scan.metrics.indexChoice);
             metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
@@ -4873,8 +4850,8 @@ class PostgresRdfEngine {
             return undefined;
         }
         const scan = isPgSqlScanCompatiblePattern(compiled)
-            ? await this.scanNative(compiled)
-            : await this.scanPostFilter(compiled);
+            ? await this.scanNative(compiled, undefined, pattern.sourceScope)
+            : await this.scanPostFilter(compiled, undefined, pattern.sourceScope);
         metrics.scannedRows += scan.metrics.matchedRows;
         metrics.indexChoices.push(scan.metrics.indexChoice);
         metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
@@ -5569,7 +5546,10 @@ class PostgresRdfEngine {
                 }
             }
             result.push({
-                pattern: compiled,
+                pattern: {
+                    ...compiled,
+                    ...(pattern.sourceScope ? { sourceScope: pattern.sourceScope } : {}),
+                },
                 variables,
                 equalities: patternEqualities(slotsByVariable),
                 pushedDownFilterIndexes: [...pushed],
@@ -5879,14 +5859,15 @@ class PostgresRdfEngine {
         }
         return this.requireDictionary().find(value);
     }
-    compileScanSql(resolved, options) {
-        const builder = new PgSqlBuilder();
+    compileScanSql(resolved, options, sourceScope) {
         const conditions = [];
         const joins = [];
+        const builder = new PgSqlBuilder();
         const queryPlan = [];
         const useMembershipSource = shouldUseMembershipSource(resolved);
         const permutation = this.choosePermutation(resolved);
         const alias = 'q';
+        this.appendPgFactSourceScope(sourceScope, alias, joins, conditions, builder);
         this.appendResolvedPatternConditions(resolved, alias, conditions, joins, builder, queryPlan, false);
         this.appendSlotTermRangeConditions(options?.slotTermRanges, alias, conditions, builder, queryPlan);
         const order = this.buildOrderClause(options, alias);
@@ -5907,6 +5888,7 @@ class PostgresRdfEngine {
             indexChoice: useMembershipSource ? 'source-membership' : permutation.name,
             queryPlan: [
                 ...(useMembershipSource ? ['Rdf3xMembershipScan'] : [`Rdf3xPermutationScan(${permutation.name})`]),
+                ...(sourceScopeHasFilters(sourceScope) ? ['PostgresFactsSourceScope'] : []),
                 ...queryPlan,
                 ...(order ? [`Rdf3xJoinOrder(${describeScanOrder(options)})`] : []),
                 ...(pagination.sql ? ['Pagination'] : []),
@@ -5968,6 +5950,7 @@ class PostgresRdfEngine {
                     queryPlan.push(`Rdf3xMergeJoin(${mergeConditions.length})`);
                 }
             }
+            this.appendPgFactSourceScope(source.entry.pattern.sourceScope, alias, joins, conditions, builder);
             this.appendResolvedPatternConditions(source.resolved, alias, conditions, joins, builder, queryPlan, options?.fenceGraphPrefix === true);
             this.appendPatternEqualityConditions(source.entry.equalities, alias, conditions, queryPlan);
             indexChoices.push(shouldUseMembershipSource(source.resolved) ? 'source-membership' : source.permutation.name);
@@ -6056,6 +6039,35 @@ class PostgresRdfEngine {
             queryPlan.push(`TermKeyRange(${range.slot})`);
         }
     }
+    appendPgFactSourceScope(scope, quadAlias, joins, conditions, builder) {
+        if (!sourceScopeHasFilters(scope)) {
+            return;
+        }
+        const sourceAlias = `${quadAlias}_source_scope`;
+        const sourceColumn = `${sourceAlias}.source`;
+        const localPathColumn = `${sourceAlias}.local_path`;
+        const sourceIdColumn = `${quadAlias}.source_file_id`;
+        joins.push(` LEFT JOIN rdf_sources ${sourceAlias} ON ${sourceAlias}.id = ${sourceIdColumn}`);
+        const allowedSources = normalizedSourceScopeValues(scope?.allowedSources ?? []);
+        if (scope?.allowedSources) {
+            conditions.push(allowedSources.length === 0
+                ? '1 = 0'
+                : `${sourceColumn} = ANY(${builder.add(allowedSources)}::text[])`);
+        }
+        if (scope?.sourcePrefix) {
+            conditions.push(pgTextPrefixCondition(sourceColumn, scope.sourcePrefix, builder));
+        }
+        if (scope?.localPathPrefix) {
+            conditions.push(pgTextPrefixCondition(localPathColumn, scope.localPathPrefix, builder));
+        }
+        const deniedSources = normalizedSourceScopeValues(scope?.deniedSources ?? []);
+        if (deniedSources.length > 0) {
+            conditions.push(`(${sourceIdColumn} IS NULL OR NOT (${sourceColumn} = ANY(${builder.add(deniedSources)}::text[])))`);
+        }
+        for (const deniedPrefix of normalizedSourceScopeValues(scope?.deniedSourcePrefixes ?? [])) {
+            conditions.push(`(${sourceIdColumn} IS NULL OR NOT (${pgTextPrefixCondition(sourceColumn, deniedPrefix, builder)}))`);
+        }
+    }
     filterRowsBySlotTermRanges(rows, ranges) {
         if (!ranges?.length)
             return rows;
@@ -6701,6 +6713,8 @@ class PostgresRdfEngine {
         return result.length;
     }
     async upsertSource(source, executor = this.requireExecutor()) {
+        const scopedDictionary = new PostgresRdfTermDictionary(executor);
+        await scopedDictionary.getOrCreate(namedNode(source.source));
         const row = await executor.query(`
       INSERT INTO rdf_sources (
         source,
@@ -7768,6 +7782,9 @@ function resolveRdfQueryCacheScope(scope) {
         allowedGraphUrls: descriptorStringArray(descriptors, 'allowedGraphUrls'),
         deniedGraphUrls: descriptorStringArray(descriptors, 'deniedGraphUrls'),
         deniedGraphPrefixes: descriptorStringArray(descriptors, 'deniedGraphPrefixes'),
+        allowedSourceUrls: descriptorStringArray(descriptors, 'allowedSourceUrls'),
+        deniedSourceUrls: descriptorStringArray(descriptors, 'deniedSourceUrls'),
+        deniedSourcePrefixes: descriptorStringArray(descriptors, 'deniedSourcePrefixes'),
     };
 }
 function rdfQueryCacheScopeHash(scopeShape) {
@@ -7793,6 +7810,9 @@ function normalizeRdfQueryCacheScope(scope) {
         allowedGraphUrls: sortedOptional(scope.allowedGraphUrls),
         deniedGraphUrls: sortedOptional(scope.deniedGraphUrls),
         deniedGraphPrefixes: sortedOptional(scope.deniedGraphPrefixes),
+        allowedSourceUrls: sortedOptional(scope.allowedSourceUrls),
+        deniedSourceUrls: sortedOptional(scope.deniedSourceUrls),
+        deniedSourcePrefixes: sortedOptional(scope.deniedSourcePrefixes),
         components: scope.components?.map((component) => normalizeRdfQueryCacheScope(component)),
     }).filter(([, value]) => value !== undefined));
 }
@@ -9983,6 +10003,23 @@ function isRdfVectorIndexLike(input) {
 function uniqueStrings(values) {
     return [...new Set(values)];
 }
+function normalizedSourceScopeValues(values) {
+    return [...new Set(values.filter((value) => value.length > 0))].sort();
+}
+function sourceScopeHasFilters(scope) {
+    return !!scope
+        && (!!scope.sourcePrefix
+            || !!scope.localPathPrefix
+            || scope.allowedSources !== undefined
+            || (scope.deniedSources?.length ?? 0) > 0
+            || (scope.deniedSourcePrefixes?.length ?? 0) > 0);
+}
+function pgTextPrefixCondition(column, prefix, builder) {
+    const lower = builder.add(prefix);
+    const upper = builder.add(`${prefix}\uffff`);
+    const exact = builder.add(prefix);
+    return `(${column} COLLATE "C") >= (${lower} COLLATE "C") AND (${column} COLLATE "C") < (${upper} COLLATE "C") AND starts_with(${column}, ${exact})`;
+}
 function rdfAccessControlCacheInvalidation(quads, source) {
     const fallbackScopes = [
         ...accessControlAffectedScopes(source?.source, source?.workspace, source?.sourceVersion),

package/dist/storage/rdf/PostgresRdfEngine.jsonld

@@ -149,10 +149,6 @@
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngineOptions__member_nativeSparqlEnabled",
           "memberFieldName": "nativeSparqlEnabled"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngineOptions__member_nativeSparqlRequired",
-          "memberFieldName": "nativeSparqlRequired"
         }
       ],
       "constructorArguments": []
@@ -634,18 +630,6 @@
               }
             ]
           }
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine_options_nativeSparqlRequired",
-          "range": {
-            "@type": "ParameterRangeUnion",
-            "parameterRangeElements": [
-              "xsd:boolean",
-              {
-                "@type": "ParameterRangeUndefined"
-              }
-            ]
-          }
         }
       ],
       "memberFields": [
@@ -876,6 +860,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_deleteTextSource",
           "memberFieldName": "deleteTextSource"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_moveTextSource",
+          "memberFieldName": "moveTextSource"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_searchText",
           "memberFieldName": "searchText"
@@ -888,6 +876,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_deleteVectorSource",
           "memberFieldName": "deleteVectorSource"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_moveVectorSource",
+          "memberFieldName": "moveVectorSource"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_searchVector",
           "memberFieldName": "searchVector"
@@ -1524,6 +1516,10 @@
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_appendSlotTermRangeConditions",
           "memberFieldName": "appendSlotTermRangeConditions"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_appendPgFactSourceScope",
+          "memberFieldName": "appendPgFactSourceScope"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine__member_filterRowsBySlotTermRanges",
           "memberFieldName": "filterRowsBySlotTermRanges"
@@ -2042,12 +2038,6 @@
               "value": {
                 "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine_options_nativeSparqlEnabled"
               }
-            },
-            {
-              "keyRaw": "nativeSparqlRequired",
-              "value": {
-                "@id": "undefineds:dist/storage/rdf/PostgresRdfEngine.jsonld#PostgresRdfEngine_options_nativeSparqlRequired"
-              }
             }
           ]
         }

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

@@ -0,0 +1,8 @@
+import type { PostgresRdfSqlExecutor } from './PostgresRdfSqlExecutor';
+type PostgresRdfIndexKind = 'text' | 'vector';
+export declare function pgHasAnyDomainTable(executor: PostgresRdfSqlExecutor, tables: string[]): Promise<boolean>;
+export declare function assertPgRequiredColumns(executor: PostgresRdfSqlExecutor, table: string, requiredColumns: string[], indexKind: PostgresRdfIndexKind): Promise<void>;
+export declare function assertPgNotNullColumn(executor: PostgresRdfSqlExecutor, table: string, column: string, indexKind: PostgresRdfIndexKind): Promise<void>;
+export declare function assertPgColumnType(executor: PostgresRdfSqlExecutor, table: string, column: string, expectedUdtName: string, indexKind: PostgresRdfIndexKind): Promise<void>;
+export declare function assertPgUniqueColumn(executor: PostgresRdfSqlExecutor, table: string, column: string, indexKind: PostgresRdfIndexKind): Promise<void>;
+export {};

package/dist/storage/rdf/PostgresRdfSchemaValidation.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgHasAnyDomainTable = pgHasAnyDomainTable;
+exports.assertPgRequiredColumns = assertPgRequiredColumns;
+exports.assertPgNotNullColumn = assertPgNotNullColumn;
+exports.assertPgColumnType = assertPgColumnType;
+exports.assertPgUniqueColumn = assertPgUniqueColumn;
+async function pgHasAnyDomainTable(executor, tables) {
+    const placeholders = tables.map((_, index) => `$${index + 1}`).join(', ');
+    const rows = await executor.query(`
+    SELECT COUNT(*) AS count
+    FROM pg_tables
+    WHERE schemaname = current_schema()
+      AND tablename IN (${placeholders})
+  `, tables);
+    return Number(rows[0]?.count ?? 0) > 0;
+}
+async function assertPgRequiredColumns(executor, table, requiredColumns, indexKind) {
+    const rows = await executor.query(`
+    SELECT column_name
+    FROM information_schema.columns
+    WHERE table_schema = current_schema()
+      AND table_name = $1
+  `, [table]);
+    if (rows.length === 0) {
+        throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: missing table ${table}`);
+    }
+    const columns = new Set(rows.map((row) => row.column_name));
+    for (const column of requiredColumns) {
+        if (!columns.has(column)) {
+            throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: missing column ${table}.${column}`);
+        }
+    }
+}
+async function assertPgNotNullColumn(executor, table, column, indexKind) {
+    const rows = await executor.query(`
+    SELECT is_nullable
+    FROM information_schema.columns
+    WHERE table_schema = current_schema()
+      AND table_name = $1
+      AND column_name = $2
+  `, [table, column]);
+    if (rows[0]?.is_nullable !== 'NO') {
+        throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: column ${table}.${column} must be NOT NULL`);
+    }
+}
+async function assertPgColumnType(executor, table, column, expectedUdtName, indexKind) {
+    const rows = await executor.query(`
+    SELECT udt_name
+    FROM information_schema.columns
+    WHERE table_schema = current_schema()
+      AND table_name = $1
+      AND column_name = $2
+  `, [table, column]);
+    if (rows.length === 0) {
+        throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: missing column ${table}.${column}`);
+    }
+    if (rows[0].udt_name !== expectedUdtName) {
+        throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: column ${table}.${column} must have type ${expectedUdtName}`);
+    }
+}
+async function assertPgUniqueColumn(executor, table, column, indexKind) {
+    const rows = await executor.query(`
+    SELECT COUNT(*) AS count
+    FROM pg_constraint constraint_info
+    JOIN pg_class table_info ON table_info.oid = constraint_info.conrelid
+    JOIN pg_namespace namespace_info ON namespace_info.oid = table_info.relnamespace
+    JOIN unnest(constraint_info.conkey) WITH ORDINALITY AS constraint_key(attnum, ordinality) ON TRUE
+    JOIN pg_attribute attribute
+      ON attribute.attrelid = constraint_info.conrelid
+     AND attribute.attnum = constraint_key.attnum
+    WHERE namespace_info.nspname = current_schema()
+      AND table_info.relname = $1
+      AND constraint_info.contype = 'u'
+      AND array_length(constraint_info.conkey, 1) = 1
+      AND attribute.attname = $2
+  `, [table, column]);
+    if (Number(rows[0]?.count ?? 0) === 0) {
+        throw new Error(`Unsupported PostgreSQL RDF ${indexKind} index schema: column ${table}.${column} must be UNIQUE`);
+    }
+}
+//# sourceMappingURL=PostgresRdfSchemaValidation.js.map

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

@@ -1,4 +1,4 @@
-import type { RdfSearchCardinalityEstimate, RdfTextChunkInput, RdfTextIndexLike, RdfTextIndexStats, RdfTextRebuildStatus, RdfTextRebuildStatusInput, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceMetadata, RdfTextSourceInput, RdfTextTermDocumentFrequency } from './types';
+import type { RdfSearchCardinalityEstimate, RdfTextChunkInput, RdfTextIndexLike, RdfTextIndexStats, RdfTextRebuildStatus, RdfTextRebuildStatusInput, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceListOptions, RdfTextSourceMetadata, RdfTextSourceInput, RdfTextTermDocumentFrequency } from './types';
 export type PostgresRdfTextSearchBackend = 'posting' | 'pg-native-fts' | 'auto';
 export interface PostgresRdfTextIndexOptions {
     driver?: 'pglite' | 'pg';
@@ -27,13 +27,16 @@ export declare class PostgresRdfTextIndex implements RdfTextIndexLike {
     close(): Promise<void>;
     clear(): Promise<void>;
     schemaVersion(): Promise<number>;
+    private readSchemaVersion;
     sourceMetadata(source: string): Promise<RdfTextSourceMetadata | undefined>;
+    listSources(options?: RdfTextSourceListOptions): Promise<RdfTextSourceMetadata[]>;
     recordRebuildStatus(input: RdfTextRebuildStatusInput): Promise<void>;
     rebuildStatus(source: string): Promise<RdfTextRebuildStatus | undefined>;
     indexText(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): Promise<void>;
     moveSource(oldSource: string, next: RdfTextSourceInput): Promise<number>;
     deleteSource(source: string): Promise<number>;
     search(options: RdfTextSearchOptions): Promise<RdfTextSearchResult[]>;
+    listSourceChunks(sourceKey: string): Promise<RdfTextSearchResult[]>;
     estimateSearchCardinality(options: RdfTextSearchOptions): Promise<RdfSearchCardinalityEstimate>;
     private searchNativeFts;
     private estimateNativeFtsSearchCardinality;
@@ -42,8 +45,8 @@ export declare class PostgresRdfTextIndex implements RdfTextIndexLike {
     private openInternal;
     private initializeSchema;
     private initializeNativeFtsSchema;
-    private backfillTermPostings;
-    private backfillNativeFtsRows;
+    private validateSchema;
+    private validateNativeFtsSchema;
     private nativeFtsEnabled;
     private canUseNativeFts;
     private upsertSource;