@memberjunction/ai-vectors-sqlserver 6.2.0-edge.0 → 6.2.0-edge.1

package/dist/models/SQLServerVectorDatabase.d.ts

@@ -30,28 +30,28 @@ export declare class SQLServerVectorDatabase extends VectorDBBase {
     constructor(apiKey: string);
     get SupportsColocatedQuery(): boolean;
     get SupportsHybridSearch(): boolean;
-    private get Host();
-    private get Schema();
-    private Qualify;
-    private Run;
-    private AssertVectorCapable;
-    private EnsureInfrastructure;
-    private GetResolvedIndex;
+    private get host();
+    private get schema();
+    private qualify;
+    private run;
+    private assertVectorCapable;
+    private ensureInfrastructure;
+    private getResolvedIndex;
     /** Validate & narrow the untyped `CreateIndexParams.additionalParams` bag into a typed config,
      *  throwing on malformed shapes rather than asserting (`as`) a shape that may not hold. */
-    private NormalizeIndexConfig;
-    private ParseSelectColumns;
+    private normalizeIndexConfig;
+    private parseSelectColumns;
     /** Resolve the schema-qualified table string for an entityColumn source spec, validating each
      *  identifier segment (accepts `[schema].[table]`, `schema.table`, or bare `table`). */
-    private QualifyEntityTable;
+    private qualifyEntityTable;
     ListIndexes(): Promise<IndexList>;
     GetIndex(params: BaseRequestParams): Promise<BaseResponse>;
     CreateIndex(params: CreateIndexParams): Promise<BaseResponse>;
-    private CreateSiblingIndex;
-    private RegisterEntityColumnIndex;
+    private createSiblingIndex;
+    private registerEntityColumnIndex;
     /** Attempt to create a DiskANN vector index; tolerate failure (preview surface / pre-existing). */
-    private TryCreateVectorIndex;
-    private UpsertRegistry;
+    private tryCreateVectorIndex;
+    private upsertRegistry;
     DeleteIndex(params: BaseRequestParams): Promise<BaseResponse>;
     EditIndex(_params: EditIndexParams): Promise<BaseResponse>;
     /**
@@ -64,7 +64,7 @@ export declare class SQLServerVectorDatabase extends VectorDBBase {
      * Servers (parallel client-to-many-servers, or mixed 2022/2025 backends), and capability differs
      * per server — a process-global flag would let one server's probe poison another's path.
      */
-    private static ApproximateSearchSupportedByHost;
+    private static approximateSearchSupportedByHost;
     ColocatedQuery(params: ColocatedQueryOptions, _contextUser?: UserInfo): Promise<ColocatedQueryResult>;
     /**
      * Execute the vector search, choosing the exact vs. approximate path and transparently falling
@@ -77,33 +77,33 @@ export declare class SQLServerVectorDatabase extends VectorDBBase {
      *  - Else attempt approximate; if it errors with a "feature not supported" signature, cache that
      *    fact and retry exact.
      */
-    private RunVectorQuery;
+    private runVectorQuery;
     /** Best-effort heuristic: does this error indicate the VECTOR_SEARCH/DiskANN surface is absent on
      *  this server? Matches on message text (brittle across CUs/locales), but only gates a fallback to
      *  an equally-correct exact query, so a false negative just rethrows and a false positive is slow,
      *  not wrong. */
-    private IsApproximateUnsupportedError;
+    private isApproximateUnsupportedError;
     /** Map a query result row to a ColocatedMatch, synthesizing metadata per storage mode. */
-    private RowToMatch;
-    private ToMetadataValue;
+    private rowToMatch;
+    private toMetadataValue;
     QueryIndex(params: QueryOptions, contextUser?: UserInfo): Promise<BaseResponse>;
     CreateRecord(record: VectorRecord, indexName?: string): Promise<BaseResponse>;
     CreateRecords(records: VectorRecord[], indexName?: string): Promise<BaseResponse>;
-    private UpsertRecords;
+    private upsertRecords;
     /** Extract the scalar key value from a vector record id (CompositeKey URL `Field|Value`). */
-    private ExtractKeyValue;
+    private extractKeyValue;
     UpdateRecord(record: UpdateOptions): Promise<BaseResponse>;
     UpdateRecords(records: UpdateOptions): Promise<BaseResponse>;
     DeleteRecord(record: VectorRecord, indexName?: string): Promise<BaseResponse>;
     DeleteRecords(records: VectorRecord[], indexName?: string): Promise<BaseResponse>;
-    private DeleteByKeys;
+    private deleteByKeys;
     DeleteAllRecords(indexName: string, _namespace?: string): Promise<BaseResponse>;
     GetRecord(params: BaseRequestParams): Promise<BaseResponse>;
     GetRecords(params: BaseRequestParams): Promise<BaseResponse>;
     ListVectorIDs(params: ListVectorIDsParams): Promise<ListVectorIDsResult>;
     BuildMetadataFilter(options: SharedIndexFilterOptions): object | undefined;
-    private ParseMetadata;
-    private Success;
-    private Failure;
+    private parseMetadata;
+    private success;
+    private failure;
 }
 //# sourceMappingURL=SQLServerVectorDatabase.d.ts.map

package/dist/models/SQLServerVectorDatabase.js

@@ -55,26 +55,26 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     //  Host connection access
     // ----------------------------------------------------------------
-    get Host() {
+    get host() {
         if (!this.ColocatedHost) {
             throw new Error('SQLServerVectorDatabase requires a host connection. Call TryWireColocatedHost()/SetColocatedHost() with the active data provider before use.');
         }
         return this.ColocatedHost;
     }
-    get Schema() {
-        return this.Host.ColocatedSchema;
+    get schema() {
+        return this.host.ColocatedSchema;
     }
-    Qualify(tableName) {
-        return `[${ValidateSqlIdentifier(this.Schema, 'schema')}].[${ValidateSqlIdentifier(tableName, 'table')}]`;
+    qualify(tableName) {
+        return `[${ValidateSqlIdentifier(this.schema, 'schema')}].[${ValidateSqlIdentifier(tableName, 'table')}]`;
     }
-    Run(sql, params) {
-        return this.Host.RunColocatedSQL(sql, params);
+    run(sql, params) {
+        return this.host.RunColocatedSQL(sql, params);
     }
     // ----------------------------------------------------------------
     //  Capability detection (fail loud)
     // ----------------------------------------------------------------
-    async AssertVectorCapable() {
-        const rows = await this.Run(`SELECT CAST(SERVERPROPERTY('ProductMajorVersion') AS INT) AS v`);
+    async assertVectorCapable() {
+        const rows = await this.run(`SELECT CAST(SERVERPROPERTY('ProductMajorVersion') AS INT) AS v`);
         const major = rows[0]?.v != null ? Number(rows[0].v) : 0;
         if (!(major >= SQLSERVER_2025_MAJOR_VERSION)) {
             throw new Error(`Colocated SQL Server vectors are unavailable: the host SQL Server major version is ${major}, ` +
@@ -82,10 +82,10 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
                 `Upgrade the server or configure this index to use an external vector database instead.`);
         }
     }
-    async EnsureInfrastructure() {
-        await this.AssertVectorCapable();
-        await this.Run(`IF OBJECT_ID('${this.Schema}.${INDEX_REGISTRY_TABLE}') IS NULL
-             CREATE TABLE ${this.Qualify(INDEX_REGISTRY_TABLE)} (
+    async ensureInfrastructure() {
+        await this.assertVectorCapable();
+        await this.run(`IF OBJECT_ID('${this.schema}.${INDEX_REGISTRY_TABLE}') IS NULL
+             CREATE TABLE ${this.qualify(INDEX_REGISTRY_TABLE)} (
                 name NVARCHAR(450) NOT NULL PRIMARY KEY,
                 dimension INT NOT NULL,
                 metric NVARCHAR(50) NOT NULL CONSTRAINT DF_${INDEX_REGISTRY_TABLE}_metric DEFAULT 'cosine',
@@ -102,19 +102,19 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     //  Registry resolution
     // ----------------------------------------------------------------
-    async GetResolvedIndex(indexName) {
-        const rows = await this.Run(`SELECT dimension, metric, storage_mode, source_table, vector_column, key_column,
+    async getResolvedIndex(indexName) {
+        const rows = await this.run(`SELECT dimension, metric, storage_mode, source_table, vector_column, key_column,
                     entity_name, select_columns, iterative_threshold
-             FROM ${this.Qualify(INDEX_REGISTRY_TABLE)} WHERE name = @p0`, [indexName]);
+             FROM ${this.qualify(INDEX_REGISTRY_TABLE)} WHERE name = @p0`, [indexName]);
         if (rows.length === 0) {
             return null;
         }
         const row = rows[0];
         const storageMode = row.storage_mode === 'entityColumn' ? 'entityColumn' : 'sibling';
-        const selectColumns = this.ParseSelectColumns(row.select_columns, storageMode);
+        const selectColumns = this.parseSelectColumns(row.select_columns, storageMode);
         const qualifiedTable = row.source_table && row.source_table.trim().length > 0
             ? row.source_table
-            : this.Qualify(indexName);
+            : this.qualify(indexName);
         return {
             dimension: Number(row.dimension),
             metric: row.metric,
@@ -133,7 +133,7 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     }
     /** Validate & narrow the untyped `CreateIndexParams.additionalParams` bag into a typed config,
      *  throwing on malformed shapes rather than asserting (`as`) a shape that may not hold. */
-    NormalizeIndexConfig(raw) {
+    normalizeIndexConfig(raw) {
         const obj = raw && typeof raw === 'object' ? raw : {};
         const cfg = {};
         if (obj['storageMode'] === 'entityColumn' || obj['storageMode'] === 'sibling') {
@@ -164,7 +164,7 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             cfg.createVectorIndex = obj['createVectorIndex'];
         return cfg;
     }
-    ParseSelectColumns(raw, storageMode) {
+    parseSelectColumns(raw, storageMode) {
         if (storageMode === 'sibling') {
             return ['metadata'];
         }
@@ -181,9 +181,9 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     }
     /** Resolve the schema-qualified table string for an entityColumn source spec, validating each
      *  identifier segment (accepts `[schema].[table]`, `schema.table`, or bare `table`). */
-    QualifyEntityTable(cfg) {
+    qualifyEntityTable(cfg) {
         const raw = (cfg.sourceTable ?? '').trim().replace(/[[\]]/g, '');
-        const parts = raw.includes('.') ? raw.split('.') : [cfg.schema ?? this.Schema, raw];
+        const parts = raw.includes('.') ? raw.split('.') : [cfg.schema ?? this.schema, raw];
         if (parts.length !== 2 || !parts[0] || !parts[1]) {
             throw new Error(`Invalid sourceTable ${JSON.stringify(cfg.sourceTable)} — expected "schema.table" or "table".`);
         }
@@ -194,13 +194,13 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     async ListIndexes() {
         try {
-            await this.EnsureInfrastructure();
-            const rows = await this.Run(`SELECT name, dimension, metric FROM ${this.Qualify(INDEX_REGISTRY_TABLE)} ORDER BY name`);
+            await this.ensureInfrastructure();
+            const rows = await this.run(`SELECT name, dimension, metric FROM ${this.qualify(INDEX_REGISTRY_TABLE)} ORDER BY name`);
             const indexes = rows.map(row => ({
                 name: row.name,
                 dimension: Number(row.dimension),
                 metric: row.metric,
-                host: this.Schema,
+                host: this.schema,
             }));
             return { indexes };
         }
@@ -211,92 +211,92 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     }
     async GetIndex(params) {
         try {
-            await this.EnsureInfrastructure();
-            const resolved = await this.GetResolvedIndex(params.id);
+            await this.ensureInfrastructure();
+            const resolved = await this.getResolvedIndex(params.id);
             if (!resolved) {
-                return this.Failure(`Index "${params.id}" not found`);
+                return this.failure(`Index "${params.id}" not found`);
             }
             const desc = {
                 name: params.id,
                 dimension: resolved.dimension,
                 metric: resolved.metric,
-                host: this.Schema,
+                host: this.schema,
             };
-            return this.Success(desc);
+            return this.success(desc);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.GetIndex error', undefined, ex);
-            return this.Failure('Error getting index');
+            return this.failure('Error getting index');
         }
     }
     async CreateIndex(params) {
         try {
-            await this.EnsureInfrastructure();
+            await this.ensureInfrastructure();
             ValidateSqlIdentifier(params.id, 'index name');
-            const cfg = this.NormalizeIndexConfig(params.additionalParams);
+            const cfg = this.normalizeIndexConfig(params.additionalParams);
             const storageMode = cfg.storageMode === 'entityColumn' ? 'entityColumn' : 'sibling';
             const dimension = params.dimension;
             const metric = params.metric || 'cosine';
             if (storageMode === 'entityColumn') {
-                return await this.RegisterEntityColumnIndex(params.id, dimension, metric, cfg);
+                return await this.registerEntityColumnIndex(params.id, dimension, metric, cfg);
             }
-            return await this.CreateSiblingIndex(params.id, dimension, metric, cfg);
+            return await this.createSiblingIndex(params.id, dimension, metric, cfg);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.CreateIndex error', undefined, ex);
-            return this.Failure(ex instanceof Error ? ex.message : 'Error creating index');
+            return this.failure(ex instanceof Error ? ex.message : 'Error creating index');
         }
     }
-    async CreateSiblingIndex(name, dimension, metric, cfg) {
-        await this.Run(`IF OBJECT_ID('${this.Schema}.${name}') IS NULL
-             CREATE TABLE ${this.Qualify(name)} (
+    async createSiblingIndex(name, dimension, metric, cfg) {
+        await this.run(`IF OBJECT_ID('${this.schema}.${name}') IS NULL
+             CREATE TABLE ${this.qualify(name)} (
                 id NVARCHAR(450) NOT NULL PRIMARY KEY,
                 embedding VECTOR(${dimension}) NULL,
                 metadata NVARCHAR(MAX) NULL,
                 content NVARCHAR(MAX) NULL
              )`);
         if (cfg.createVectorIndex !== false) {
-            await this.TryCreateVectorIndex(name, this.Qualify(name), 'embedding', metric);
+            await this.tryCreateVectorIndex(name, this.qualify(name), 'embedding', metric);
         }
-        await this.UpsertRegistry(name, {
+        await this.upsertRegistry(name, {
             dimension, metric, storageMode: 'sibling',
-            sourceTable: this.Qualify(name), vectorColumn: 'embedding', keyColumn: 'id',
+            sourceTable: this.qualify(name), vectorColumn: 'embedding', keyColumn: 'id',
             entityName: null, selectColumns: ['metadata'], threshold: cfg.iterativeFilterThreshold ?? null,
         });
         LogStatus(`SQLServerVectorDatabase: Created sibling index "${name}" (dim=${dimension}, metric=${metric})`);
-        return this.Success({ name, dimension, metric, storageMode: 'sibling' });
+        return this.success({ name, dimension, metric, storageMode: 'sibling' });
     }
-    async RegisterEntityColumnIndex(name, dimension, metric, cfg) {
+    async registerEntityColumnIndex(name, dimension, metric, cfg) {
         if (!cfg.sourceTable) {
-            return this.Failure('entityColumn storage mode requires additionalParams.sourceTable');
+            return this.failure('entityColumn storage mode requires additionalParams.sourceTable');
         }
-        const qualified = this.QualifyEntityTable(cfg);
+        const qualified = this.qualifyEntityTable(cfg);
         const vectorColumn = ValidateSqlIdentifier(cfg.vectorColumn ?? 'Embedding', 'vectorColumn');
         const keyColumn = ValidateSqlIdentifier(cfg.keyColumn ?? 'ID', 'keyColumn');
         if (cfg.createVectorIndex !== false) {
-            await this.TryCreateVectorIndex(name, qualified, vectorColumn, metric);
+            await this.tryCreateVectorIndex(name, qualified, vectorColumn, metric);
         }
-        await this.UpsertRegistry(name, {
+        await this.upsertRegistry(name, {
             dimension, metric, storageMode: 'entityColumn',
             sourceTable: qualified, vectorColumn, keyColumn,
             entityName: cfg.entityName ?? null, selectColumns: cfg.selectColumns ?? [],
             threshold: cfg.iterativeFilterThreshold ?? null,
         });
         LogStatus(`SQLServerVectorDatabase: Registered entityColumn index "${name}" → ${qualified}.${vectorColumn} (key=${keyColumn})`);
-        return this.Success({ name, dimension, metric, storageMode: 'entityColumn', sourceTable: qualified });
+        return this.success({ name, dimension, metric, storageMode: 'entityColumn', sourceTable: qualified });
     }
     /** Attempt to create a DiskANN vector index; tolerate failure (preview surface / pre-existing). */
-    async TryCreateVectorIndex(indexName, qualifiedTable, vectorColumn, metric) {
+    async tryCreateVectorIndex(indexName, qualifiedTable, vectorColumn, metric) {
         try {
-            await this.Run(`CREATE VECTOR INDEX [VIX_${indexName}_embedding] ON ${qualifiedTable}([${vectorColumn}])
+            await this.run(`CREATE VECTOR INDEX [VIX_${indexName}_embedding] ON ${qualifiedTable}([${vectorColumn}])
                  WITH (METRIC = '${metric}', TYPE = 'DiskANN')`);
         }
         catch (ex) {
             LogStatus(`SQLServerVectorDatabase: vector index not created for "${indexName}" (continuing): ${ex instanceof Error ? ex.message : String(ex)}`);
         }
     }
-    async UpsertRegistry(name, r) {
-        await this.Run(`MERGE ${this.Qualify(INDEX_REGISTRY_TABLE)} AS t
+    async upsertRegistry(name, r) {
+        await this.run(`MERGE ${this.qualify(INDEX_REGISTRY_TABLE)} AS t
              USING (SELECT @p0 AS name) AS s ON t.name = s.name
              WHEN MATCHED THEN UPDATE SET dimension=@p1, metric=@p2, storage_mode=@p3, source_table=@p4,
                 vector_column=@p5, key_column=@p6, entity_name=@p7, select_columns=@p8, iterative_threshold=@p9
@@ -306,22 +306,22 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     }
     async DeleteIndex(params) {
         try {
-            await this.EnsureInfrastructure();
-            const resolved = await this.GetResolvedIndex(params.id);
+            await this.ensureInfrastructure();
+            const resolved = await this.getResolvedIndex(params.id);
             // Only drop a table we own (sibling mode). entityColumn tables belong to the app.
             if (resolved?.storageMode === 'sibling') {
-                await this.Run(`IF OBJECT_ID('${this.Schema}.${params.id}') IS NOT NULL DROP TABLE ${this.Qualify(params.id)}`);
+                await this.run(`IF OBJECT_ID('${this.schema}.${params.id}') IS NOT NULL DROP TABLE ${this.qualify(params.id)}`);
             }
-            await this.Run(`DELETE FROM ${this.Qualify(INDEX_REGISTRY_TABLE)} WHERE name = @p0`, [params.id]);
-            return this.Success(null);
+            await this.run(`DELETE FROM ${this.qualify(INDEX_REGISTRY_TABLE)} WHERE name = @p0`, [params.id]);
+            return this.success(null);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.DeleteIndex error', undefined, ex);
-            return this.Failure('Error deleting index');
+            return this.failure('Error deleting index');
         }
     }
     async EditIndex(_params) {
-        return this.Failure('EditIndex is not currently supported for colocated SQL Server vectors');
+        return this.failure('EditIndex is not currently supported for colocated SQL Server vectors');
     }
     // ----------------------------------------------------------------
     //  Query — VECTOR_SEARCH TVF with cardinality-based exact/approximate dispatch
@@ -336,9 +336,9 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
      * Servers (parallel client-to-many-servers, or mixed 2022/2025 backends), and capability differs
      * per server — a process-global flag would let one server's probe poison another's path.
      */
-    static { this.ApproximateSearchSupportedByHost = new WeakMap(); }
+    static { this.approximateSearchSupportedByHost = new WeakMap(); }
     async ColocatedQuery(params, _contextUser) {
-        const resolved = await this.GetResolvedIndex(params.indexName);
+        const resolved = await this.getResolvedIndex(params.indexName);
         if (!resolved) {
             throw new Error(`SQLServerVectorDatabase: index "${params.indexName}" is not registered`);
         }
@@ -354,9 +354,9 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             topK: SafeTopK(params.topK || 10),
             filter: params.filter,
         };
-        const rows = await this.RunVectorQuery(build, resolved, !!params.filter);
+        const rows = await this.runVectorQuery(build, resolved, !!params.filter);
         const includeMetadata = params.includeMetadata !== false;
-        return { matches: rows.map(row => this.RowToMatch(row, resolved, includeMetadata)) };
+        return { matches: rows.map(row => this.rowToMatch(row, resolved, includeMetadata)) };
     }
     /**
      * Execute the vector search, choosing the exact vs. approximate path and transparently falling
@@ -369,51 +369,51 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
      *  - Else attempt approximate; if it errors with a "feature not supported" signature, cache that
      *    fact and retry exact.
      */
-    async RunVectorQuery(build, resolved, hasFilter) {
-        const cache = SQLServerVectorDatabase_1.ApproximateSearchSupportedByHost;
-        let useExact = cache.get(this.Host) === false;
+    async runVectorQuery(build, resolved, hasFilter) {
+        const cache = SQLServerVectorDatabase_1.approximateSearchSupportedByHost;
+        let useExact = cache.get(this.host) === false;
         if (!useExact && hasFilter) {
             const countQ = BuildFilterCountQuery(resolved.target, build.filter);
-            const countRows = await this.Run(countQ.sql, countQ.params);
+            const countRows = await this.run(countQ.sql, countQ.params);
             const n = countRows[0]?.n != null ? Number(countRows[0].n) : Number.MAX_SAFE_INTEGER;
             useExact = n <= resolved.threshold;
         }
         if (useExact) {
             const exact = BuildExactVectorQuery(build);
-            return this.Run(exact.sql, exact.params);
+            return this.run(exact.sql, exact.params);
         }
         const approx = BuildApproximateVectorQuery(build);
         try {
-            const rows = await this.Run(approx.sql, approx.params);
-            cache.set(this.Host, true);
+            const rows = await this.run(approx.sql, approx.params);
+            cache.set(this.host, true);
             return rows;
         }
         catch (ex) {
-            if (!this.IsApproximateUnsupportedError(ex)) {
+            if (!this.isApproximateUnsupportedError(ex)) {
                 throw ex;
             }
-            cache.set(this.Host, false);
+            cache.set(this.host, false);
             LogStatus('SQLServerVectorDatabase: VECTOR_SEARCH/WITH APPROXIMATE is unavailable on this server; falling back to exact VECTOR_DISTANCE search.');
             const exact = BuildExactVectorQuery(build);
-            return this.Run(exact.sql, exact.params);
+            return this.run(exact.sql, exact.params);
         }
     }
     /** Best-effort heuristic: does this error indicate the VECTOR_SEARCH/DiskANN surface is absent on
      *  this server? Matches on message text (brittle across CUs/locales), but only gates a fallback to
      *  an equally-correct exact query, so a false negative just rethrows and a false positive is slow,
      *  not wrong. */
-    IsApproximateUnsupportedError(ex) {
+    isApproximateUnsupportedError(ex) {
         const msg = ex instanceof Error ? ex.message : String(ex);
         return /APPROXIMATE|VECTOR_SEARCH|Unknown object type 'VECTOR'/i.test(msg);
     }
     /** Map a query result row to a ColocatedMatch, synthesizing metadata per storage mode. */
-    RowToMatch(row, resolved, includeMetadata) {
+    rowToMatch(row, resolved, includeMetadata) {
         const distance = Number(row['distance'] ?? 0);
         const score = DistanceToScore(distance, resolved.metric);
         if (resolved.storageMode === 'sibling') {
             const match = { id: String(row['id']), score };
             if (includeMetadata && row['metadata']) {
-                match.metadata = this.ParseMetadata(row['metadata']);
+                match.metadata = this.parseMetadata(row['metadata']);
             }
             return match;
         }
@@ -432,14 +432,14 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             for (const col of resolved.target.selectColumns) {
                 const value = row[col];
                 if (value != null) {
-                    metadata[col] = this.ToMetadataValue(value);
+                    metadata[col] = this.toMetadataValue(value);
                 }
             }
             match.metadata = metadata;
         }
         return match;
     }
-    ToMetadataValue(value) {
+    toMetadataValue(value) {
         if (typeof value === 'number' || typeof value === 'boolean') {
             return value;
         }
@@ -453,10 +453,10 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             const vector = 'vector' in params ? params.vector : undefined;
             const indexName = 'id' in params ? params.id : undefined;
             if (!vector) {
-                return this.Failure('QueryIndex requires a vector in the params');
+                return this.failure('QueryIndex requires a vector in the params');
             }
             if (!indexName) {
-                return this.Failure('QueryIndex requires an index name (params.id)');
+                return this.failure('QueryIndex requires an index name (params.id)');
             }
             const result = await this.ColocatedQuery({
                 indexName,
@@ -471,12 +471,12 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
                 score: m.score,
                 ...(m.metadata ? { metadata: m.metadata } : {}),
             }));
-            const response = { matches, namespace: this.Schema };
-            return this.Success(response);
+            const response = { matches, namespace: this.schema };
+            return this.success(response);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.QueryIndex error', undefined, ex);
-            return this.Failure('Error querying index');
+            return this.failure('Error querying index');
         }
     }
     // ----------------------------------------------------------------
@@ -484,61 +484,61 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     async CreateRecord(record, indexName) {
         if (!indexName) {
-            return this.Failure('indexName is required for CreateRecord');
+            return this.failure('indexName is required for CreateRecord');
         }
-        return this.UpsertRecords([record], indexName);
+        return this.upsertRecords([record], indexName);
     }
     async CreateRecords(records, indexName) {
         if (!indexName) {
-            return this.Failure('indexName is required for CreateRecords');
+            return this.failure('indexName is required for CreateRecords');
         }
-        return this.UpsertRecords(records, indexName);
+        return this.upsertRecords(records, indexName);
     }
-    async UpsertRecords(records, indexName) {
+    async upsertRecords(records, indexName) {
         try {
-            const resolved = await this.GetResolvedIndex(indexName);
+            const resolved = await this.getResolvedIndex(indexName);
             if (!resolved) {
-                return this.Failure(`index "${indexName}" is not registered`);
+                return this.failure(`index "${indexName}" is not registered`);
             }
             for (const record of records) {
                 const dim = resolved.dimension || record.values.length;
                 if (resolved.storageMode === 'entityColumn') {
                     // The entity row already exists and is app-owned; only set its vector column.
-                    const keyValue = this.ExtractKeyValue(record.id);
-                    await this.Run(`UPDATE ${resolved.target.qualifiedTable}
+                    const keyValue = this.extractKeyValue(record.id);
+                    await this.run(`UPDATE ${resolved.target.qualifiedTable}
                          SET [${resolved.target.vectorColumn}] = CAST(@p1 AS VECTOR(${dim}))
                          WHERE [${resolved.keyColumn}] = @p0`, [keyValue, VectorJson(record.values)]);
                 }
                 else {
                     const content = DeriveContent(record.metadata);
-                    await this.Run(`MERGE ${this.Qualify(indexName)} AS t
+                    await this.run(`MERGE ${this.qualify(indexName)} AS t
                          USING (SELECT @p0 AS id) AS s ON t.id = s.id
                          WHEN MATCHED THEN UPDATE SET embedding = CAST(@p1 AS VECTOR(${dim})), metadata = @p2, content = @p3
                          WHEN NOT MATCHED THEN INSERT (id, embedding, metadata, content)
                             VALUES (@p0, CAST(@p1 AS VECTOR(${dim})), @p2, @p3);`, [record.id, VectorJson(record.values), JSON.stringify(record.metadata ?? {}), content]);
                 }
             }
-            return this.Success({ upsertedCount: records.length });
+            return this.success({ upsertedCount: records.length });
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.UpsertRecords error', undefined, ex);
-            return this.Failure('Error upserting records');
+            return this.failure('Error upserting records');
         }
     }
     /** Extract the scalar key value from a vector record id (CompositeKey URL `Field|Value`). */
-    ExtractKeyValue(recordId) {
+    extractKeyValue(recordId) {
         const parts = recordId.split('|');
         return parts.length >= 2 ? parts[1] : recordId;
     }
     async UpdateRecord(record) {
         const indexName = record['indexName'];
         if (!indexName) {
-            return this.Failure('indexName property is required on the UpdateOptions object');
+            return this.failure('indexName property is required on the UpdateOptions object');
         }
         if (!record.values) {
-            return this.Success(null);
+            return this.success(null);
         }
-        return this.UpsertRecords([{ id: record.id, values: record.values, metadata: record.metadata }], indexName);
+        return this.upsertRecords([{ id: record.id, values: record.values, metadata: record.metadata }], indexName);
     }
     async UpdateRecords(records) {
         return this.UpdateRecord(records);
@@ -548,52 +548,52 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     async DeleteRecord(record, indexName) {
         if (!indexName) {
-            return this.Failure('indexName is required for DeleteRecord');
+            return this.failure('indexName is required for DeleteRecord');
         }
-        return this.DeleteByKeys([record.id], indexName);
+        return this.deleteByKeys([record.id], indexName);
     }
     async DeleteRecords(records, indexName) {
         if (!indexName) {
-            return this.Failure('indexName is required for DeleteRecords');
+            return this.failure('indexName is required for DeleteRecords');
         }
-        return this.DeleteByKeys(records.map(r => r.id), indexName);
+        return this.deleteByKeys(records.map(r => r.id), indexName);
     }
-    async DeleteByKeys(ids, indexName) {
+    async deleteByKeys(ids, indexName) {
         try {
-            const resolved = await this.GetResolvedIndex(indexName);
+            const resolved = await this.getResolvedIndex(indexName);
             if (!resolved) {
-                return this.Failure(`index "${indexName}" is not registered`);
+                return this.failure(`index "${indexName}" is not registered`);
             }
             for (const id of ids) {
                 if (resolved.storageMode === 'entityColumn') {
                     // Don't delete app-owned rows — null out the vector instead.
-                    await this.Run(`UPDATE ${resolved.target.qualifiedTable} SET [${resolved.target.vectorColumn}] = NULL WHERE [${resolved.keyColumn}] = @p0`, [this.ExtractKeyValue(id)]);
+                    await this.run(`UPDATE ${resolved.target.qualifiedTable} SET [${resolved.target.vectorColumn}] = NULL WHERE [${resolved.keyColumn}] = @p0`, [this.extractKeyValue(id)]);
                 }
                 else {
-                    await this.Run(`DELETE FROM ${this.Qualify(indexName)} WHERE id = @p0`, [id]);
+                    await this.run(`DELETE FROM ${this.qualify(indexName)} WHERE id = @p0`, [id]);
                 }
             }
-            return this.Success(null);
+            return this.success(null);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.DeleteByKeys error', undefined, ex);
-            return this.Failure('Error deleting records');
+            return this.failure('Error deleting records');
         }
     }
     async DeleteAllRecords(indexName, _namespace) {
         try {
-            const resolved = await this.GetResolvedIndex(indexName);
+            const resolved = await this.getResolvedIndex(indexName);
             if (resolved?.storageMode === 'entityColumn') {
-                await this.Run(`UPDATE ${resolved.target.qualifiedTable} SET [${resolved.target.vectorColumn}] = NULL`);
+                await this.run(`UPDATE ${resolved.target.qualifiedTable} SET [${resolved.target.vectorColumn}] = NULL`);
             }
             else {
-                await this.Run(`DELETE FROM ${this.Qualify(indexName)}`);
+                await this.run(`DELETE FROM ${this.qualify(indexName)}`);
             }
-            return this.Success(null);
+            return this.success(null);
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.DeleteAllRecords error', undefined, ex);
-            return this.Failure('Error deleting all records');
+            return this.failure('Error deleting all records');
         }
     }
     // ----------------------------------------------------------------
@@ -603,23 +603,23 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
         try {
             const indexName = typeof params.data?.indexName === 'string' ? params.data.indexName : undefined;
             if (!indexName) {
-                return this.Failure('params.data.indexName is required');
+                return this.failure('params.data.indexName is required');
             }
-            const resolved = await this.GetResolvedIndex(indexName);
+            const resolved = await this.getResolvedIndex(indexName);
             if (!resolved) {
-                return this.Failure(`index "${indexName}" is not registered`);
+                return this.failure(`index "${indexName}" is not registered`);
             }
             const t = resolved.target;
-            const rows = await this.Run(`SELECT c.[${t.keyColumn}] AS id, CAST(c.[${t.vectorColumn}] AS NVARCHAR(MAX)) AS embedding_text
-                 FROM ${t.qualifiedTable} c WHERE c.[${t.keyColumn}] = @p0`, [this.ExtractKeyValue(params.id)]);
+            const rows = await this.run(`SELECT c.[${t.keyColumn}] AS id, CAST(c.[${t.vectorColumn}] AS NVARCHAR(MAX)) AS embedding_text
+                 FROM ${t.qualifiedTable} c WHERE c.[${t.keyColumn}] = @p0`, [this.extractKeyValue(params.id)]);
             if (rows.length === 0) {
-                return this.Failure(`Record "${params.id}" not found`);
+                return this.failure(`Record "${params.id}" not found`);
             }
-            return this.Success({ id: String(rows[0].id), values: ParseVectorJson(rows[0].embedding_text) });
+            return this.success({ id: String(rows[0].id), values: ParseVectorJson(rows[0].embedding_text) });
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.GetRecord error', undefined, ex);
-            return this.Failure('Error getting record');
+            return this.failure('Error getting record');
         }
     }
     async GetRecords(params) {
@@ -627,37 +627,37 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             const indexName = typeof params.data?.indexName === 'string' ? params.data.indexName : undefined;
             const ids = Array.isArray(params.data?.ids) ? params.data.ids : undefined;
             if (!indexName) {
-                return this.Failure('params.data.indexName is required');
+                return this.failure('params.data.indexName is required');
             }
             if (!ids || ids.length === 0) {
-                return this.Failure('params.data.ids is required');
+                return this.failure('params.data.ids is required');
             }
-            const resolved = await this.GetResolvedIndex(indexName);
+            const resolved = await this.getResolvedIndex(indexName);
             if (!resolved) {
-                return this.Failure(`index "${indexName}" is not registered`);
+                return this.failure(`index "${indexName}" is not registered`);
             }
             const t = resolved.target;
-            const keyValues = ids.map(id => this.ExtractKeyValue(id));
+            const keyValues = ids.map(id => this.extractKeyValue(id));
             const placeholders = keyValues.map((_v, i) => `@p${i}`).join(', ');
-            const rows = await this.Run(`SELECT c.[${t.keyColumn}] AS id, CAST(c.[${t.vectorColumn}] AS NVARCHAR(MAX)) AS embedding_text
+            const rows = await this.run(`SELECT c.[${t.keyColumn}] AS id, CAST(c.[${t.vectorColumn}] AS NVARCHAR(MAX)) AS embedding_text
                  FROM ${t.qualifiedTable} c WHERE c.[${t.keyColumn}] IN (${placeholders})`, keyValues);
-            return this.Success(rows.map(r => ({ id: String(r.id), values: ParseVectorJson(r.embedding_text) })));
+            return this.success(rows.map(r => ({ id: String(r.id), values: ParseVectorJson(r.embedding_text) })));
         }
         catch (ex) {
             LogError('SQLServerVectorDatabase.GetRecords error', undefined, ex);
-            return this.Failure('Error getting records');
+            return this.failure('Error getting records');
         }
     }
     async ListVectorIDs(params) {
         try {
-            const resolved = await this.GetResolvedIndex(params.IndexName);
+            const resolved = await this.getResolvedIndex(params.IndexName);
             if (!resolved) {
                 return { IDs: [] };
             }
             const t = resolved.target;
             const limit = params.Limit ?? 100;
             const offset = params.PaginationToken ? parseInt(params.PaginationToken, 10) : 0;
-            const rows = await this.Run(`SELECT c.[${t.keyColumn}] AS id FROM ${t.qualifiedTable} c
+            const rows = await this.run(`SELECT c.[${t.keyColumn}] AS id FROM ${t.qualifiedTable} c
                  ORDER BY c.[${t.keyColumn}] OFFSET @p0 ROWS FETCH NEXT @p1 ROWS ONLY`, [offset, limit]);
             const ids = rows.map(r => String(r.id));
             const nextToken = ids.length < limit ? undefined : String(offset + ids.length);
@@ -675,7 +675,7 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
     // ----------------------------------------------------------------
     //  Helpers
     // ----------------------------------------------------------------
-    ParseMetadata(raw) {
+    parseMetadata(raw) {
         if (raw == null) {
             return {};
         }
@@ -689,10 +689,10 @@ let SQLServerVectorDatabase = class SQLServerVectorDatabase extends VectorDBBase
             return {};
         }
     }
-    Success(data) {
+    success(data) {
         return { success: true, message: '', data };
     }
-    Failure(message) {
+    failure(message) {
         return { success: false, message: message || 'An error occurred', data: null };
     }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memberjunction/ai-vectors-sqlserver",
   "type": "module",
-  "version": "6.2.0-edge.0",
+  "version": "6.2.0-edge.1",
   "description": "SQL Server 2025 native VECTOR implementation for AI Vector Database (colocated)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,9 +11,9 @@
   "author": "MemberJunction.com",
   "license": "BUSL-1.1",
   "dependencies": {
-    "@memberjunction/ai-vectordb": "6.2.0-edge.0",
-    "@memberjunction/core": "6.2.0-edge.0",
-    "@memberjunction/global": "6.2.0-edge.0",
+    "@memberjunction/ai-vectordb": "6.2.0-edge.1",
+    "@memberjunction/core": "6.2.0-edge.1",
+    "@memberjunction/global": "6.2.0-edge.1",
     "dotenv": "^17.2.4"
   },
   "devDependencies": {