agentlang 0.10.8 → 0.11.0

package/src/runtime/module.ts

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { createCodedError } from './errors/coded-error.js';
 import {
   AttributeDefinition,
   Expr,
@@ -2631,7 +2632,11 @@ export class Module {
 
   getEntry(entryName: string): ModuleEntry {
     const idx: number = this.getEntryIndex(entryName);
-    if (idx < 0) throw new Error(`Entry ${entryName} not found in module ${this.name}`);
+    if (idx < 0)
+      throw createCodedError(
+        `Entry ${entryName} not found in module ${this.name}`,
+        'AL_MOD_ENTRY_NOT_FOUND'
+      );
     return this.entries[idx];
   }
 
@@ -2646,7 +2651,10 @@ export class Module {
     if (e instanceof Record) {
       return e as Record;
     }
-    throw new Error(`${recordName} is not a record in module ${this.name}`);
+    throw createCodedError(
+      `${recordName} is not a record in module ${this.name}`,
+      'AL_MOD_NOT_A_RECORD'
+    );
   }
 
   removeEntry(entryName: string): boolean {
@@ -2942,7 +2950,7 @@ export function isModule(name: string): boolean {
 export function fetchModule(moduleName: string): Module {
   const module: Module | undefined = getModuleDb().get(moduleName);
   if (module === undefined) {
-    throw new Error(`Module not found - ${moduleName}`);
+    throw createCodedError(`Module not found - ${moduleName}`, 'AL_MOD_MODULE_NOT_FOUND');
   }
   return module;
 }
@@ -3481,7 +3489,7 @@ export function getEntity(name: string, moduleName: string): Entity | undefined
 export function fetchEntity(path: Path): Entity {
   const e = getEntity(path.getEntryName(), path.getModuleName());
   if (e === undefined) {
-    throw new Error(`Entity not found - ${path.asFqName()}`);
+    throw createCodedError(`Entity not found - ${path.asFqName()}`, 'AL_MOD_ENTITY_NOT_FOUND');
   }
   return e;
 }
@@ -3513,7 +3521,10 @@ export function getEvent(name: string, moduleName: string): Event {
   if (fr.module.isEvent(fr.entryName)) {
     return fr.module.getEntry(fr.entryName) as Event;
   }
-  throw new Error(`Event ${fr.entryName} not found in module ${fr.moduleName}`);
+  throw createCodedError(
+    `Event ${fr.entryName} not found in module ${fr.moduleName}`,
+    'AL_MOD_EVENT_NOT_FOUND'
+  );
 }
 
 export function maybeGetEvent(name: string, moduleName: string): Event | undefined {
@@ -3529,7 +3540,10 @@ export function getRecord(name: string, moduleName: string): Record {
   if (fr.module.isRecord(fr.entryName)) {
     return fr.module.getEntry(fr.entryName) as Record;
   }
-  throw new Error(`Record ${fr.entryName} not found in module ${fr.moduleName}`);
+  throw createCodedError(
+    `Record ${fr.entryName} not found in module ${fr.moduleName}`,
+    'AL_MOD_RECORD_NOT_FOUND'
+  );
 }
 
 export function getRelationship(name: string, moduleName: string): Relationship {
@@ -3537,7 +3551,10 @@ export function getRelationship(name: string, moduleName: string): Relationship
   if (fr.module.isRelationship(fr.entryName)) {
     return fr.module.getEntry(fr.entryName) as Relationship;
   }
-  throw new Error(`Relationship ${fr.entryName} not found in module ${fr.moduleName}`);
+  throw createCodedError(
+    `Relationship ${fr.entryName} not found in module ${fr.moduleName}`,
+    'AL_MOD_RELATIONSHIP_NOT_FOUND'
+  );
 }
 
 export function getAllBetweenRelationships(): Relationship[] {
@@ -3707,7 +3724,10 @@ function checkOneOfValue(attrSpec: AttributeSpec, attrName: string, attrValue: a
   const vals: Set<string> | undefined = getEnumValues(attrSpec);
   if (vals) {
     if (!vals.has(attrValue as string)) {
-      throw new Error(`Value of ${attrName} must be one of [${[...vals]}]`);
+      throw createCodedError(
+        `Value of ${attrName} must be one of [${[...vals]}]`,
+        'AL_MOD_TYPE_MISMATCH'
+      );
     }
     return true;
   }
@@ -3725,7 +3745,10 @@ function getCheckPredicate(attrSpec: AttributeSpec): any {
 function validateType(attrName: string, attrValue: any, attrSpec: AttributeSpec) {
   if (attrSpec.type == 'Path') {
     if (!isPath(attrValue, getRefSpec(attrSpec))) {
-      throw new Error(`Failed to validate Path ${attrValue} passed to ${attrName}`);
+      throw createCodedError(
+        `Failed to validate Path ${attrValue} passed to ${attrName}`,
+        'AL_MOD_TYPE_MISMATCH'
+      );
     }
   }
   let predic = getCheckPredicate(attrSpec);
@@ -3733,16 +3756,22 @@ function validateType(attrName: string, attrValue: any, attrSpec: AttributeSpec)
   if (predic !== undefined) {
     if (isArrayAttribute(attrSpec)) {
       if (!(attrValue instanceof Array)) {
-        throw new Error(`${attrName} expects an array of values`);
+        throw createCodedError(`${attrName} expects an array of values`, 'AL_MOD_TYPE_MISMATCH');
       } else {
         if (!attrValue.every(predic)) {
-          throw new Error(`Invalid value in the array passed to ${attrName}`);
+          throw createCodedError(
+            `Invalid value in the array passed to ${attrName}`,
+            'AL_MOD_TYPE_MISMATCH'
+          );
         }
       }
     } else {
       if (!checkOneOfValue(attrSpec, attrName, attrValue)) {
         if (!predic(attrValue)) {
-          throw new Error(`Invalid value ${attrValue} specified for ${attrName}`);
+          throw createCodedError(
+            `Invalid value ${attrValue} specified for ${attrName}`,
+            'AL_MOD_TYPE_MISMATCH'
+          );
         }
       }
     }
@@ -4307,7 +4336,10 @@ export function makeInstance(
   if (schema.size > 0) {
     attributes.forEach((value: any, key: string) => {
       if (!schema.has(key)) {
-        throw new Error(`Invalid attribute '${key}' specified for ${moduleName}/${entryName}`);
+        throw createCodedError(
+          `Invalid attribute '${key}' specified for ${moduleName}/${entryName}`,
+          'AL_MOD_INVALID_ATTR'
+        );
       }
       const spec: AttributeSpec = getAttributeSpec(schema, key);
       if (value !== null && value !== undefined) validateType(key, value, spec);

package/src/runtime/modules/ai.ts

@@ -85,6 +85,7 @@ const AgentEvalType = 'eval';
 // --- Agent cancellation infrastructure ---
 
 export class AgentCancelledException extends Error {
+  readonly agentlangCode = 'AL_AGENT_CANCELLED';
   constructor(chatId: string) {
     super(`Agent cancelled for chatId: ${chatId}`);
     this.name = 'AgentCancelledException';
@@ -1286,8 +1287,16 @@ async function parseHelper(stmt: string, env: Environment): Promise<any> {
   return env.getLastResult();
 }
 
-export async function findAgentByName(name: string, env: Environment): Promise<AgentInstance> {
-  const result = await parseHelper(`{${AgentFqName} {name? "${name}"}}`, env);
+export async function findAgentByName(name: string, _env: Environment): Promise<AgentInstance> {
+  // Match findProviderForLLM: Agent rows are upserted at load under GlobalEnvironment / bootstrap
+  // tenant. A request env (e.g. after setActiveEvent) may not see those rows; use a GlobalEnvironment
+  // child for the lookup.
+  const lookupEnv = new Environment('agent-by-name-lookup', GlobalEnvironment);
+  const result = await parseAndEvaluateStatement(
+    `{${AgentFqName} {name? "${name}"}}`,
+    undefined,
+    lookupEnv
+  );
   if (result instanceof Array && result.length > 0) {
     const agentInstance: Instance = result[0];
     return AgentInstance.FromInstance(agentInstance);

package/src/runtime/modules/auth.ts

@@ -27,6 +27,7 @@ import {
   set_getUserTenantId,
   PathAttributeName,
 } from '../defs.js';
+import { createCodedError } from '../errors/coded-error.js';
 import {
   DbContext,
   getManyByRawQuery,
@@ -934,6 +935,11 @@ async function updatePermissionCacheForRole(role: string, env: Environment) {
   }
 }
 
+/** Matches the built-in superuser role name (case-insensitive). */
+function isGlobalAdminRoleName(role: string | undefined | null): boolean {
+  return typeof role === 'string' && role.length > 0 && role.toLowerCase() === 'admin';
+}
+
 export async function userHasPermissions(
   userId: string,
   resourceFqName: string,
@@ -959,6 +965,10 @@ export async function userHasPermissions(
     }
     UserRoleCache.set(userId, userRoles);
   }
+  // Real admin users keep full access even when agents/workflows set assumedRole (narrowing).
+  if (userRoles?.some((r: string) => isGlobalAdminRoleName(r))) {
+    return true;
+  }
   let tempRoles = userRoles;
   const assumedRole = env.getAssumedRole();
   if (assumedRole) {
@@ -967,12 +977,7 @@ export async function userHasPermissions(
       await updatePermissionCacheForRole(assumedRole, env);
     }
   }
-  if (
-    tempRoles &&
-    tempRoles.find((role: string) => {
-      return role === 'admin';
-    })
-  ) {
+  if (tempRoles?.some((r: string) => isGlobalAdminRoleName(r))) {
     return true;
   }
   const [c, r, u, d] = [
@@ -1041,7 +1046,7 @@ function fetchAuthImpl(): AgentlangAuth {
   if (runtimeAuth) {
     return runtimeAuth;
   } else {
-    throw new Error('Auth not initialized');
+    throw createCodedError('Auth not initialized', 'AL_AUTH_NOT_INITIALIZED');
   }
 }
 
@@ -1111,7 +1116,9 @@ export async function forgotPasswordUser(username: string, env: Environment): Pr
     const email = username.toLowerCase();
     const allowed = await fetchAuthImpl().userExistsInIdentityProvider(email, env);
     if (!allowed) {
-      throw new UserNotFoundError('Email not registered');
+      throw new UserNotFoundError('Email not registered', {
+        agentlangCode: 'AL_AUTH_EMAIL_NOT_REGISTERED',
+      });
     }
     await fetchAuthImpl().forgotPassword(email, env);
     return { status: 'ok', message: 'Password reset code sent' };
@@ -1261,7 +1268,9 @@ export async function changePassword(
       return undefined;
     }
   } else {
-    throw new UnauthorisedError(`No active session for user ${user}`);
+    throw new UnauthorisedError(`No active session for user ${user}`, {
+      agentlangCode: 'AL_AUTH_NO_ACTIVE_SESSION_CHANGE_PW',
+    });
   }
 }
 
@@ -1288,7 +1297,9 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
     try {
       // Validate JWT structure first
       if (!isJwtToken(token)) {
-        throw new UnauthorisedError('Invalid JWT token structure');
+        throw new UnauthorisedError('Invalid JWT token structure', {
+          agentlangCode: 'AL_AUTH_JWT_STRUCTURE_INVALID',
+        });
       }
 
       // Verify the JWT token directly with Cognito
@@ -1303,7 +1314,9 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
       const email = payload.email || payload['cognito:username'];
 
       if (!userId) {
-        throw new UnauthorisedError('Invalid JWT token: missing user identifier');
+        throw new UnauthorisedError('Invalid JWT token: missing user identifier', {
+          agentlangCode: 'AL_AUTH_JWT_MISSING_USER_ID',
+        });
       }
 
       let localUser = null;
@@ -1319,7 +1332,9 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
         logger.warn(
           `User not found in local database for JWT token. Email: ${email}, UserId: ${userId}`
         );
-        throw new UnauthorisedError(`User not found in local database`);
+        throw new UnauthorisedError(`User not found in local database`, {
+          agentlangCode: 'AL_AUTH_JWT_USER_NOT_IN_DB',
+        });
       }
 
       // Use the local user's ID for consistency
@@ -1328,12 +1343,16 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
       // Check if user status is 'Active'
       const userStatus = localUser.lookup('status');
       if (userStatus !== 'Active') {
-        throw new UnauthorisedError(`User account is not active. Status: ${userStatus}`);
+        throw new UnauthorisedError(`User account is not active. Status: ${userStatus}`, {
+          agentlangCode: 'AL_AUTH_USER_NOT_ACTIVE_JWT',
+        });
       }
 
       const sess = await findUserSession(localUserId, env);
       if (!sess) {
-        throw new UnauthorisedError(`No session found for user ${email}, UserId: ${userId}`);
+        throw new UnauthorisedError(`No session found for user ${email}, UserId: ${userId}`, {
+          agentlangCode: 'AL_AUTH_NO_SESSION_JWT',
+        });
       }
       // For JWT tokens, we use the token itself as sessionId for tracking
       return { sessionId: sess.lookup('id'), userId: localUserId };
@@ -1345,7 +1364,9 @@ async function verifyJwtToken(token: string, env?: Environment): Promise<ActiveS
         errorName: err.name,
         errorMessage: err.message,
       });
-      throw new UnauthorisedError('JWT token verification failed');
+      throw new UnauthorisedError('JWT token verification failed', {
+        agentlangCode: 'AL_AUTH_JWT_VERIFY_WRAPPER',
+      });
     }
   };
   if (needCommit) {
@@ -1368,7 +1389,9 @@ async function verifySessionToken(token: string, env?: Environment): Promise<Act
       if (user) {
         const userStatus = user.lookup('status');
         if (userStatus !== 'Active') {
-          throw new UnauthorisedError(`User account is not active. Status: ${userStatus}`);
+          throw new UnauthorisedError(`User account is not active. Status: ${userStatus}`, {
+            agentlangCode: 'AL_AUTH_USER_NOT_ACTIVE_SESSION',
+          });
         }
       }
 
@@ -1378,7 +1401,9 @@ async function verifySessionToken(token: string, env?: Environment): Promise<Act
         return { sessionId: sessId, userId: userId };
       } else {
         logger.warn(`No active session found for user '${userId}'`);
-        throw new UnauthorisedError(`No active session for user '${userId}'`);
+        throw new UnauthorisedError(`No active session for user '${userId}'`, {
+          agentlangCode: 'AL_AUTH_NO_ACTIVE_SESSION_TOKEN',
+        });
       }
     } catch (err: any) {
       if (err instanceof UnauthorisedError) {
@@ -1390,7 +1415,9 @@ async function verifySessionToken(token: string, env?: Environment): Promise<Act
         errorMessage: err.message,
         sessionId: sessId,
       });
-      throw new UnauthorisedError('Session verification failed');
+      throw new UnauthorisedError('Session verification failed', {
+        agentlangCode: 'AL_AUTH_SESSION_VERIFY_WRAPPER',
+      });
     }
   };
   if (needCommit) {

package/src/runtime/modules/core.ts

@@ -167,6 +167,16 @@ entity Migration {
   downs String @optional
 }
 
+// Custom HTTP error messages. \`target\` is "*" for a universal (code-only) override,
+// or "module/Entry" for an entity-specific one. \`message\` may contain the
+// {{code}} and {{message}} placeholders, substituted at resolution time.
+entity errorMessage {
+  id UUID @id @default(uuid()),
+  target String @default("*") @indexed,
+  code String @indexed,
+  message String
+}
+
 @public event Query {
   q Any
 }
@@ -283,6 +293,22 @@ export async function lookupTimersWithRunningStatus(): Promise<Instance[]> {
   return await parseAndEvaluateStatement(`{agentlang/timer {status? "R"}}`);
 }
 
+/**
+ * Look up a custom error-message template stored in the `agentlang/errorMessage`
+ * system entity. `target` is "*" for a universal override or "module/Entry" for an
+ * entity-specific one. Returns the stored `message`, or undefined when none exists.
+ */
+export async function lookupCustomErrorMessage(
+  target: string,
+  code: string
+): Promise<string | undefined> {
+  const r: any = await parseAndEvaluateStatement(
+    `{${DefaultModuleName}/errorMessage {target? "${escapeSpecialChars(target)}", code? "${escapeSpecialChars(code)}"}}`
+  );
+  const insts: Instance[] = Array.isArray(r) ? r : r ? [r] : [];
+  return insts.length > 0 ? insts[0].lookup('message') : undefined;
+}
+
 async function addAudit(
   env: Environment,
   action: 'c' | 'd' | 'u',

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

@@ -45,6 +45,8 @@ import {
   TenantAttributeName,
   UnauthorisedError,
 } from '../../defs.js';
+import { createCodedError } from '../../errors/coded-error.js';
+import { mapDatabaseError } from './db-errors.js';
 import { saveMigration } from '../../modules/core.js';
 import { getAppSpec } from '../../loader.js';
 import { WhereClause } from '../interface.js';
@@ -393,9 +395,10 @@ async function validateSchemaInProd(dataSource: DataSource) {
   );
   if (pendingQueries.length > 0) {
     const pending = pendingQueries.join('\n  ');
-    throw new Error(
+    throw createCodedError(
       `Schema mismatch detected: the app model does not match the database schema. ` +
-        `Run migrations before starting in production mode.\n  Pending changes:\n  ${pending}`
+        `Run migrations before starting in production mode.\n  Pending changes:\n  ${pending}`,
+      'AL_DB_SCHEMA_MISMATCH_PROD'
     );
   }
 }
@@ -431,8 +434,9 @@ async function maybeHandleMigrations(dataSource: DataSource) {
       const simulation = await simulateMigration(dataSource);
       if (!simulation.success) {
         logger.error(`Migration simulation failed:\n  ${simulation.errors.join('\n  ')}`);
-        throw new Error(
-          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`
+        throw createCodedError(
+          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`,
+          'AL_DB_MIGRATION_SIMULATION_FAILED'
         );
       }
       logger.info('Migration simulation passed.');
@@ -443,8 +447,9 @@ async function maybeHandleMigrations(dataSource: DataSource) {
       const simulation = await simulateMigration(dataSource);
       if (!simulation.success) {
         logger.error(`Migration simulation failed:\n  ${simulation.errors.join('\n  ')}`);
-        throw new Error(
-          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`
+        throw createCodedError(
+          `Migration aborted: simulation failed.\n  ${simulation.errors.join('\n  ')}`,
+          'AL_DB_MIGRATION_SIMULATION_FAILED'
         );
       }
       logger.info('Migration simulation passed, applying changes...');
@@ -530,7 +535,10 @@ function getDsFunction(
     case 'sqljs':
       return makeSqljsDataSource;
     default:
-      throw new Error(`Unsupported database type - ${config?.type}`);
+      throw createCodedError(
+        `Unsupported database type - ${config?.type}`,
+        'AL_DB_UNSUPPORTED_TYPE'
+      );
   }
 }
 
@@ -595,7 +603,10 @@ export async function initDatabase(config: DatabaseConfig | undefined) {
         await initVectorStore(vectEnts, DbContext.getGlobalContext());
       }
     } else {
-      throw new Error(`Unsupported database type - ${getDbType(AppConfig?.store)}`);
+      throw createCodedError(
+        `Unsupported database type - ${getDbType(AppConfig?.store)}`,
+        'AL_DB_UNSUPPORTED_TYPE_INIT'
+      );
     }
   }
 }
@@ -617,9 +628,13 @@ async function insertRowsHelper(
   ctx: DbContext,
   doUpsert: boolean
 ): Promise<void> {
-  const repo = getDatasourceForTransaction(ctx.txnId).getRepository(tableName);
-  if (doUpsert) await repo.save(rows);
-  else await repo.insert(rows);
+  try {
+    const repo = getDatasourceForTransaction(ctx.txnId).getRepository(tableName);
+    if (doUpsert) await repo.save(rows);
+    else await repo.insert(rows);
+  } catch (err) {
+    mapDatabaseError(err);
+  }
 }
 
 export async function addRowForFullTextSearch(
@@ -884,7 +899,10 @@ export async function insertRows(
       }
     }
   } else {
-    throw new UnauthorisedError({ opr: 'insert', entity: tableName });
+    throw new UnauthorisedError(
+      { opr: 'insert', entity: tableName },
+      { agentlangCode: 'AL_DB_INSERT_UNAUTHORIZED' }
+    );
   }
 }
 
@@ -926,7 +944,10 @@ export async function insertBetweenRow(
     const row = Object.fromEntries(attrs);
     await insertRow(n, row, ctx.clone().setNeedAuthCheck(false), false);
   } else {
-    throw new UnauthorisedError({ opr: 'insert', entity: n });
+    throw new UnauthorisedError(
+      { opr: 'insert', entity: n },
+      { agentlangCode: 'AL_DB_BETWEEN_INSERT_UNAUTHORIZED' }
+    );
   }
 }
 
@@ -1046,12 +1067,16 @@ export async function updateRow(
   updateObj: object,
   ctx: DbContext
 ): Promise<boolean> {
-  await getDatasourceForTransaction(ctx.txnId)
-    .createQueryBuilder()
-    .update(tableName)
-    .set(updateObj)
-    .where(objectToWhereClause(queryObj, queryVals), queryVals)
-    .execute();
+  try {
+    await getDatasourceForTransaction(ctx.txnId)
+      .createQueryBuilder()
+      .update(tableName)
+      .set(updateObj)
+      .where(objectToWhereClause(queryObj, queryVals), queryVals)
+      .execute();
+  } catch (err) {
+    mapDatabaseError(err);
+  }
   return true;
 }
 
@@ -1069,12 +1094,16 @@ function queryObjectAsWhereClause(qobj: QueryObject): string {
 
 export async function hardDeleteRow(tableName: string, queryObject: QueryObject, ctx: DbContext) {
   const clause = queryObjectAsWhereClause(queryObject);
-  await getDatasourceForTransaction(ctx.txnId)
-    .createQueryBuilder()
-    .delete()
-    .from(tableName)
-    .where(clause, Object.fromEntries(queryObject))
-    .execute();
+  try {
+    await getDatasourceForTransaction(ctx.txnId)
+      .createQueryBuilder()
+      .delete()
+      .from(tableName)
+      .where(clause, Object.fromEntries(queryObject))
+      .execute();
+  } catch (err) {
+    mapDatabaseError(err);
+  }
   return true;
 }
 
@@ -1090,7 +1119,7 @@ function mkBetweenClause(tableName: string | undefined, k: string, queryVals: an
     delete queryVals[k];
     return s;
   } else {
-    throw new Error(`between requires an array argument, not ${ov}`);
+    throw createCodedError(`between requires an array argument, not ${ov}`, 'AL_DB_BETWEEN_ARRAY');
   }
 }
 
@@ -1112,7 +1141,10 @@ function objectToWhereClause(queryObj: object, queryVals: any, tableName?: strin
       } else if (op === '<>' || op === '!=') {
         op = 'IS NOT';
       } else {
-        throw new Error(`Operator ${op} cannot be appplied to SQL NULL`);
+        throw createCodedError(
+          `Operator ${op} cannot be appplied to SQL NULL`,
+          'AL_DB_NULL_OPERATOR'
+        );
       }
     }
     const v = isnullcheck ? 'NULL' : `:${k}`;
@@ -1143,7 +1175,10 @@ function objectToRawWhereClause(queryObj: object, queryVals: any, tableName?: st
       } else if (op === '<>' || op === '!=') {
         op = 'IS NOT';
       } else {
-        throw new Error(`Operator ${op} cannot be appplied to SQL NULL`);
+        throw createCodedError(
+          `Operator ${op} cannot be appplied to SQL NULL`,
+          'AL_DB_NULL_OPERATOR'
+        );
       }
     }
     let clause = '';
@@ -1274,8 +1309,12 @@ export async function getMany(
     qb.skip(querySpec.offset);
   }
   qb.where(queryStr, querySpec.queryVals);
-  if (hasAggregates) return await qb.getRawMany();
-  else return await qb.getMany();
+  try {
+    if (hasAggregates) return await qb.getRawMany();
+    else return await qb.getMany();
+  } catch (err) {
+    mapDatabaseError(err);
+  }
 }
 
 export async function getManyByRawQuery(
@@ -1287,7 +1326,11 @@ export async function getManyByRawQuery(
     .getRepository(tableName)
     .createQueryBuilder();
   qb.where('', querySpec.queryVals);
-  return await qb.getMany();
+  try {
+    return await qb.getMany();
+  } catch (err) {
+    mapDatabaseError(err);
+  }
 }
 
 export async function getManyByJoin(
@@ -1348,7 +1391,7 @@ export async function getManyByJoin(
     }
   });
   if (querySpec.intoSpec === undefined) {
-    throw new Error('SELECT-INTO pattern is missing');
+    throw createCodedError('SELECT-INTO pattern is missing', 'AL_DB_SELECT_INTO_MISSING');
   }
   const intos = querySpec.intoSpec.size > 0 ? intoSpecToSql(querySpec.intoSpec) : '';
   const intos_sep = intos.length === 0 ? '' : ',';
@@ -1370,7 +1413,11 @@ export async function getManyByJoin(
   }
   logger.debug(`Join Query: ${sql}`);
   const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
-  return await qb.query(sql);
+  try {
+    return await qb.query(sql);
+  } catch (err) {
+    mapDatabaseError(err);
+  }
 }
 
 function intoSpecToSql(intoSpec: Map<string, string>): string {
@@ -1440,7 +1487,11 @@ export async function getAllConnected(
       connAlias,
       buildQueryFromConnnectionInfo(connAlias, alias, connInfo)
     );
-  return await qb.getRawMany();
+  try {
+    return await qb.getRawMany();
+  } catch (err) {
+    mapDatabaseError(err);
+  }
 }
 
 const transactionsDb: Map<string, QueryRunner> = new Map<string, QueryRunner>();
@@ -1453,7 +1504,7 @@ export async function startDbTransaction(): Promise<string> {
     transactionsDb.set(txnId, queryRunner);
     return txnId;
   } else {
-    throw new Error('Database not initialized');
+    throw createCodedError('Database not initialized', 'AL_DB_NOT_INITIALIZED');
   }
 }
 
@@ -1461,13 +1512,13 @@ function getDatasourceForTransaction(txnId: string | undefined): DataSource | En
   if (txnId) {
     const qr: QueryRunner | undefined = transactionsDb.get(txnId);
     if (qr === undefined) {
-      throw new Error(`Transaction not found - ${txnId}`);
+      throw createCodedError(`Transaction not found - ${txnId}`, 'AL_DB_TXN_NOT_FOUND');
     } else {
       return qr.manager;
     }
   } else {
     if (defaultDataSource !== undefined) return defaultDataSource;
-    else throw new Error('No default datasource is initialized');
+    else throw createCodedError('No default datasource is initialized', 'AL_DB_NO_DATASOURCE');
   }
 }