agentlang 0.9.5 → 0.9.7

package/src/runtime/modules/auth.ts

@@ -959,9 +959,15 @@ export async function userHasPermissions(
     }
     UserRoleCache.set(userId, userRoles);
   }
+  let tempRoles = userRoles;
+  const escalatedRole = env.getEscalatedRole();
+  if (escalatedRole) {
+    tempRoles = userRoles.slice();
+    tempRoles.push(escalatedRole);
+  }
   if (
-    userRoles &&
-    userRoles.find((role: string) => {
+    tempRoles &&
+    tempRoles.find((role: string) => {
       return role === 'admin';
     })
   ) {
@@ -973,9 +979,9 @@ export async function userHasPermissions(
     perms.has(RbacPermissionFlag.UPDATE),
     perms.has(RbacPermissionFlag.DELETE),
   ];
-  if (userRoles !== null) {
-    for (let i = 0; i < userRoles.length; ++i) {
-      const permInsts: RbacPermission[] | undefined = RolePermissionsCache.get(userRoles[i]);
+  if (tempRoles !== null) {
+    for (let i = 0; i < tempRoles.length; ++i) {
+      const permInsts: RbacPermission[] | undefined = RolePermissionsCache.get(tempRoles[i]);
       if (permInsts) {
         if (
           permInsts.find((p: RbacPermission) => {

package/src/runtime/resolvers/interface.ts

@@ -174,7 +174,7 @@ export class Resolver {
     entryName: string,
     moduleName: string,
     query: string,
-    options?: Map<string, any>
+    options?: any
   ): Promise<any> {
     return this.notImpl(`fullTextSearch(${entryName}, ${moduleName}, ${query}, ${options})`);
   }

package/src/runtime/resolvers/sqldb/database.ts

@@ -45,6 +45,7 @@ import {
 import { saveMigration } from '../../modules/core.js';
 import { getAppSpec } from '../../loader.js';
 import { WhereClause } from '../interface.js';
+import { AppConfig } from '../../state.js';
 
 export let defaultDataSource: DataSource | undefined;
 
@@ -227,9 +228,10 @@ function makeSqliteDataSource(
 ): DataSource {
   const synchronize = needSync();
   //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
-  return new DataSource({
+  const dbPath = config?.dbname || mkDbName();
+  const ds = new DataSource({
     type: 'better-sqlite3',
-    database: config?.dbname || mkDbName(),
+    database: dbPath,
     synchronize: synchronize,
     entities: entities,
     migrationsRun: false,
@@ -239,6 +241,25 @@ function makeSqliteDataSource(
       undefined: 'ignore',
     },
   });
+  const originalInit = ds.initialize.bind(ds);
+  ds.initialize = async () => {
+    const res = await originalInit();
+    try {
+      const { load } = await import('sqlite-vec');
+      const driver = ds.driver as any;
+      const db = driver.databaseConnection || driver.nativeDatabase;
+      if (db) {
+        load(db);
+        logger.info('sqlite-vec extension loaded successfully');
+      }
+    } catch (err: any) {
+      logger.warn(
+        `Failed to load sqlite-vec extension: ${err.message}. Vector operations may not be available.`
+      );
+    }
+    return res;
+  };
+  return ds;
 }
 
 async function execMigrationSql(dataSource: DataSource, sql: string[]) {
@@ -323,9 +344,7 @@ function makeSqljsDataSource(
   });
 }
 
-const DbType = 'sqlite';
-
-function getDbType(config?: DatabaseConfig): string {
+function forceGetDbType(config: DatabaseConfig | undefined): string {
   if (config?.type) return config.type;
   let envType: string | undefined;
   try {
@@ -335,6 +354,13 @@ function getDbType(config?: DatabaseConfig): string {
   } catch {}
   if (envType) return envType;
   if (isBrowser()) return 'sqljs';
+  return 'sqlite';
+}
+
+let DbType: string | undefined;
+
+function getDbType(config: DatabaseConfig | undefined): string {
+  if (DbType === undefined) DbType = forceGetDbType(config);
   return DbType;
 }
 
@@ -358,16 +384,25 @@ function getDsFunction(
 }
 
 export function isUsingSqlite(): boolean {
-  return getDbType() == 'sqlite';
+  return getDbType(AppConfig?.store) == 'sqlite';
 }
 
 export function isUsingSqljs(): boolean {
-  return getDbType() == 'sqljs';
+  return getDbType(AppConfig?.store) == 'sqljs';
 }
 
-export function isVectorStoreSupported(): boolean {
-  // Only Postgres supports pgvector
-  return getDbType() === 'postgres';
+export async function isVectorStoreSupported(): Promise<boolean> {
+  const dbType = getDbType(AppConfig?.store);
+  if (dbType === 'postgres') return true;
+  if (dbType === 'sqlite') {
+    try {
+      const sqliteVecModule = await import('sqlite-vec');
+      return !!sqliteVecModule;
+    } catch {
+      return false;
+    }
+  }
+  return false;
 }
 
 export async function initDatabase(config: DatabaseConfig | undefined) {
@@ -403,7 +438,7 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
         await initVectorStore(vectEnts, DbContext.getGlobalContext());
       }
     } else {
-      throw new Error(`Unsupported database type - ${DbType}`);
+      throw new Error(`Unsupported database type - ${getDbType(AppConfig?.store)}`);
     }
   }
 }
@@ -436,49 +471,69 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
-  if (!isVectorStoreSupported()) return;
+  if (!(await isVectorStoreSupported())) return;
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
     const tenantId = await ctx.getTenantId();
-    const { default: pgvector } = await import('pgvector');
-    await qb
-      .insert()
-      .into(vecTableName)
-      .values([{ id: id, embedding: pgvector.toSql(vect), __tenant__: tenantId }])
-      .execute();
+    const dbType = getDbType(AppConfig?.store);
+    if (dbType === 'postgres') {
+      const { default: pgvector } = await import('pgvector');
+      await qb
+        .insert()
+        .into(vecTableName)
+        .values([{ id: id, embedding: pgvector.toSql(vect), __tenant__: tenantId }])
+        .execute();
+    } else {
+      await qb
+        .insert()
+        .into(vecTableName)
+        .values([{ id: id, embedding: new Float32Array(vect) }])
+        .execute();
+    }
   } catch (err: any) {
     logger.error(`Failed to add row to vector store - ${err}`);
   }
 }
 
 export async function initVectorStore(tableNames: string[], ctx: DbContext) {
-  if (!isVectorStoreSupported()) {
-    logger.info(`Vector store not supported for ${getDbType()}, skipping init...`);
+  if (!(await isVectorStoreSupported())) {
+    logger.info(`Vector store not supported for ${getDbType(AppConfig?.store)}, skipping init...`);
     return;
   }
+  const dbType = getDbType(AppConfig?.store);
   let notInited = true;
-  tableNames.forEach(async (vecTableName: string) => {
+  for (const vecTableName of tableNames) {
     const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
-    if (notInited) {
-      let failure = false;
-      try {
-        await vecRepo.query('CREATE EXTENSION IF NOT EXISTS vector');
-      } catch (err: any) {
-        logger.error(`Failed to initialize vector store - ${err}`);
-        failure = true;
+    if (dbType === 'postgres') {
+      if (notInited) {
+        let failure = false;
+        try {
+          await vecRepo.query('CREATE EXTENSION IF NOT EXISTS vector');
+        } catch (err: any) {
+          logger.error(`Failed to initialize vector store - ${err}`);
+          failure = true;
+        }
+        if (failure) continue;
+        notInited = false;
       }
-      if (failure) return;
-      notInited = false;
+      await vecRepo.query(
+        `CREATE TABLE IF NOT EXISTS ${vecTableName} (
+            id varchar PRIMARY KEY,
+            embedding vector(${DefaultVectorDimension}),
+            ${TenantAttributeName} varchar,
+            __is_deleted__ boolean default false
+          )`
+      );
+    } else {
+      // sqlite-vec - vec0 doesn't support type declarations for metadata columns
+      await vecRepo.query(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${vecTableName} USING vec0(
+            id TEXT PRIMARY KEY,
+            embedding FLOAT[${DefaultVectorDimension}])`
+      );
     }
-    await vecRepo.query(
-      `CREATE TABLE IF NOT EXISTS ${vecTableName} (
-          id varchar PRIMARY KEY,
-          embedding vector(${DefaultVectorDimension}),
-          __is_deleted__ boolean default false
-        )`
-    );
-  });
+  }
 }
 
 export async function vectorStoreSearch(
@@ -487,7 +542,7 @@ export async function vectorStoreSearch(
   limit: number,
   ctx: DbContext
 ): Promise<any> {
-  if (!isVectorStoreSupported()) {
+  if (!(await isVectorStoreSupported())) {
     // Not supported on sqljs/sqlite
     return [];
   }
@@ -501,17 +556,31 @@ export async function vectorStoreSearch(
     }
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
-    const { default: pgvector } = await import('pgvector');
-    let ownersJoinCond: string = '';
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
+    let ownersJoinCond: string = '';
     if (!hasGlobalPerms) {
       const ot = ownersTable(tableName);
       ownersJoinCond = `inner join ${ot} on
-${ot}.path = ${vecTableName}.id and ${ot}.user_id = '${ctx.authInfo.userId}' and ${ot}.r = true
-and ${ot}.${TenantAttributeName} = '${tenantId}' and ${vecTableName}.${TenantAttributeName} = '${tenantId}'`;
+ ${ot}.path = ${vecTableName}.id and ${ot}.user_id = '${ctx.authInfo.userId}' and ${ot}.r = true
+ and ${ot}.${TenantAttributeName} = '${tenantId}'`;
+    }
+    if (dbType === 'postgres') {
+      const { default: pgvector } = await import('pgvector');
+      const sql = `select ${vecTableName}.id from ${vecTableName} ${ownersJoinCond} order by embedding <-> $1 LIMIT ${limit}`;
+      const args = pgvector.toSql(searchVec);
+      return await qb.query(sql, [args]);
+    } else {
+      // sqlite-vec - join with main table to filter by tenant
+      const alias = tableName.toLowerCase();
+      const sql = `SELECT ${vecTableName}.id FROM ${vecTableName}
+        INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
+        ${ownersJoinCond}
+        WHERE ${alias}.${TenantAttributeName} = '${tenantId}' AND ${alias}.${DeletedFlagAttributeName} = false AND ${vecTableName}.embedding MATCH $1
+        LIMIT ${limit}`;
+      const args = new Float32Array(searchVec);
+      return await qb.query(sql, [args]);
     }
-    const sql = `select ${vecTableName}.id from ${vecTableName} ${ownersJoinCond} order by embedding <-> $1 LIMIT ${limit}`;
-    return await qb.query(sql, [pgvector.toSql(searchVec)]);
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
     return [];
@@ -523,16 +592,30 @@ export async function vectorStoreSearchEntryExists(
   id: string,
   ctx: DbContext
 ): Promise<boolean> {
-  if (!isVectorStoreSupported()) return false;
+  if (!(await isVectorStoreSupported())) return false;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
-    const result: any[] = await qb.query(
-      `select id from ${vecTableName} where id = $1 abd ${TenantAttributeName} = '${tenantId}'`,
-      [id]
-    );
-    return result !== null && result.length > 0;
+
+    if (dbType === 'postgres') {
+      const result: any[] = await qb.query(
+        `select id from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
+        [id]
+      );
+      return result !== null && result.length > 0;
+    } else {
+      // sqlite-vec - join with main table to verify tenant
+      const alias = tableName.toLowerCase();
+      const result: any[] = await qb.query(
+        `SELECT ${vecTableName}.id FROM ${vecTableName}
+         INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
+         WHERE ${vecTableName}.id = $1 AND ${alias}.${TenantAttributeName} = '${tenantId}'`,
+        [id]
+      );
+      return result !== null && result.length > 0;
+    }
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
   }
@@ -540,15 +623,22 @@ export async function vectorStoreSearchEntryExists(
 }
 
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
-  if (!isVectorStoreSupported()) return;
+  if (!(await isVectorStoreSupported())) return;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
-    await qb.query(
-      `delete from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
-      [id]
-    );
+
+    if (dbType === 'postgres') {
+      await qb.query(
+        `delete from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
+        [id]
+      );
+    } else {
+      // sqlite-vec - delete just by id (ownership verified by caller)
+      await qb.query(`delete from ${vecTableName} where id = $1`, [id]);
+    }
   } catch (err: any) {
     logger.error(`Vector store delete failed - ${err}`);
   }