@memberjunction/server 5.31.0 → 5.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memberjunction/server",
-  "version": "5.31.0",
+  "version": "5.33.0",
   "description": "MemberJunction: This project provides API access via GraphQL to the common data store.",
   "main": "./dist/index.js",
   "types": "./src/index.ts",
@@ -27,73 +27,73 @@
     "@as-integrations/express5": "^1.0.0",
     "@graphql-tools/schema": "latest",
     "@graphql-tools/utils": "^11.0.0",
-    "@memberjunction/actions": "5.31.0",
-    "@memberjunction/actions-apollo": "5.31.0",
-    "@memberjunction/actions-base": "5.31.0",
-    "@memberjunction/actions-bizapps-accounting": "5.31.0",
-    "@memberjunction/actions-bizapps-crm": "5.31.0",
-    "@memberjunction/actions-bizapps-formbuilders": "5.31.0",
-    "@memberjunction/actions-bizapps-lms": "5.31.0",
-    "@memberjunction/actions-bizapps-social": "5.31.0",
-    "@memberjunction/ai": "5.31.0",
-    "@memberjunction/ai-agent-manager": "5.31.0",
-    "@memberjunction/ai-agent-manager-actions": "5.31.0",
-    "@memberjunction/ai-agents": "5.31.0",
-    "@memberjunction/ai-core-plus": "5.31.0",
-    "@memberjunction/ai-mcp-client": "5.31.0",
-    "@memberjunction/ai-prompts": "5.31.0",
-    "@memberjunction/ai-provider-bundle": "5.31.0",
-    "@memberjunction/ai-vector-sync": "5.31.0",
-    "@memberjunction/ai-vectordb": "5.31.0",
-    "@memberjunction/ai-vectors-pinecone": "5.31.0",
-    "@memberjunction/aiengine": "5.31.0",
-    "@memberjunction/api-keys": "5.31.0",
-    "@memberjunction/auth-providers": "5.31.0",
-    "@memberjunction/codegen-lib": "5.31.0",
-    "@memberjunction/communication-ms-graph": "5.31.0",
-    "@memberjunction/communication-sendgrid": "5.31.0",
-    "@memberjunction/communication-types": "5.31.0",
-    "@memberjunction/component-registry-client-sdk": "5.31.0",
-    "@memberjunction/computer-use-engine": "5.31.0",
-    "@memberjunction/config": "5.31.0",
-    "@memberjunction/core": "5.31.0",
-    "@memberjunction/core-actions": "5.31.0",
-    "@memberjunction/core-entities": "5.31.0",
-    "@memberjunction/core-entities-server": "5.31.0",
-    "@memberjunction/data-context": "5.31.0",
-    "@memberjunction/data-context-server": "5.31.0",
-    "@memberjunction/doc-utils": "5.31.0",
-    "@memberjunction/encryption": "5.31.0",
-    "@memberjunction/entity-communications-base": "5.31.0",
-    "@memberjunction/entity-communications-server": "5.31.0",
-    "@memberjunction/external-change-detection": "5.31.0",
-    "@memberjunction/generic-database-provider": "5.31.0",
-    "@memberjunction/global": "5.31.0",
-    "@memberjunction/graphql-dataprovider": "5.31.0",
-    "@memberjunction/integration-engine": "5.31.0",
-    "@memberjunction/integration-schema-builder": "5.31.0",
-    "@memberjunction/interactive-component-types": "5.31.0",
-    "@memberjunction/notifications": "5.31.0",
-    "@memberjunction/postgresql-dataprovider": "5.31.0",
-    "@memberjunction/queue": "5.31.0",
-    "@memberjunction/redis-provider": "5.31.0",
-    "@memberjunction/scheduling-actions": "5.31.0",
-    "@memberjunction/scheduling-base-types": "5.31.0",
-    "@memberjunction/scheduling-engine": "5.31.0",
-    "@memberjunction/scheduling-engine-base": "5.31.0",
-    "@memberjunction/schema-engine": "5.31.0",
-    "@memberjunction/search-engine": "5.31.0",
-    "@memberjunction/server-extensions-core": "5.31.0",
-    "@memberjunction/skip-types": "5.31.0",
-    "@memberjunction/sql-dialect": "5.31.0",
-    "@memberjunction/sqlserver-dataprovider": "5.31.0",
-    "@memberjunction/storage": "5.31.0",
-    "@memberjunction/tag-engine": "5.31.0",
-    "@memberjunction/tag-engine-base": "5.31.0",
-    "@memberjunction/templates": "5.31.0",
-    "@memberjunction/testing-engine": "5.31.0",
-    "@memberjunction/testing-engine-base": "5.31.0",
-    "@memberjunction/version-history": "5.31.0",
+    "@memberjunction/actions": "5.33.0",
+    "@memberjunction/actions-apollo": "5.33.0",
+    "@memberjunction/actions-base": "5.33.0",
+    "@memberjunction/actions-bizapps-accounting": "5.33.0",
+    "@memberjunction/actions-bizapps-crm": "5.33.0",
+    "@memberjunction/actions-bizapps-formbuilders": "5.33.0",
+    "@memberjunction/actions-bizapps-lms": "5.33.0",
+    "@memberjunction/actions-bizapps-social": "5.33.0",
+    "@memberjunction/ai": "5.33.0",
+    "@memberjunction/ai-agent-manager": "5.33.0",
+    "@memberjunction/ai-agent-manager-actions": "5.33.0",
+    "@memberjunction/ai-agents": "5.33.0",
+    "@memberjunction/ai-core-plus": "5.33.0",
+    "@memberjunction/ai-mcp-client": "5.33.0",
+    "@memberjunction/ai-prompts": "5.33.0",
+    "@memberjunction/ai-provider-bundle": "5.33.0",
+    "@memberjunction/ai-vector-sync": "5.33.0",
+    "@memberjunction/ai-vectordb": "5.33.0",
+    "@memberjunction/ai-vectors-pinecone": "5.33.0",
+    "@memberjunction/aiengine": "5.33.0",
+    "@memberjunction/api-keys": "5.33.0",
+    "@memberjunction/auth-providers": "5.33.0",
+    "@memberjunction/codegen-lib": "5.33.0",
+    "@memberjunction/communication-ms-graph": "5.33.0",
+    "@memberjunction/communication-sendgrid": "5.33.0",
+    "@memberjunction/communication-types": "5.33.0",
+    "@memberjunction/component-registry-client-sdk": "5.33.0",
+    "@memberjunction/computer-use-engine": "5.33.0",
+    "@memberjunction/config": "5.33.0",
+    "@memberjunction/core": "5.33.0",
+    "@memberjunction/core-actions": "5.33.0",
+    "@memberjunction/core-entities": "5.33.0",
+    "@memberjunction/core-entities-server": "5.33.0",
+    "@memberjunction/data-context": "5.33.0",
+    "@memberjunction/data-context-server": "5.33.0",
+    "@memberjunction/doc-utils": "5.33.0",
+    "@memberjunction/encryption": "5.33.0",
+    "@memberjunction/entity-communications-base": "5.33.0",
+    "@memberjunction/entity-communications-server": "5.33.0",
+    "@memberjunction/external-change-detection": "5.33.0",
+    "@memberjunction/generic-database-provider": "5.33.0",
+    "@memberjunction/global": "5.33.0",
+    "@memberjunction/graphql-dataprovider": "5.33.0",
+    "@memberjunction/integration-engine": "5.33.0",
+    "@memberjunction/integration-schema-builder": "5.33.0",
+    "@memberjunction/interactive-component-types": "5.33.0",
+    "@memberjunction/notifications": "5.33.0",
+    "@memberjunction/postgresql-dataprovider": "5.33.0",
+    "@memberjunction/queue": "5.33.0",
+    "@memberjunction/redis-provider": "5.33.0",
+    "@memberjunction/scheduling-actions": "5.33.0",
+    "@memberjunction/scheduling-base-types": "5.33.0",
+    "@memberjunction/scheduling-engine": "5.33.0",
+    "@memberjunction/scheduling-engine-base": "5.33.0",
+    "@memberjunction/schema-engine": "5.33.0",
+    "@memberjunction/search-engine": "5.33.0",
+    "@memberjunction/server-extensions-core": "5.33.0",
+    "@memberjunction/skip-types": "5.33.0",
+    "@memberjunction/sql-dialect": "5.33.0",
+    "@memberjunction/sqlserver-dataprovider": "5.33.0",
+    "@memberjunction/storage": "5.33.0",
+    "@memberjunction/tag-engine": "5.33.0",
+    "@memberjunction/tag-engine-base": "5.33.0",
+    "@memberjunction/templates": "5.33.0",
+    "@memberjunction/testing-engine": "5.33.0",
+    "@memberjunction/testing-engine-base": "5.33.0",
+    "@memberjunction/version-history": "5.33.0",
     "@types/compression": "^1.8.1",
     "@types/cors": "^2.8.19",
     "@types/jsonwebtoken": "9.0.10",

package/src/__tests__/databaseAbstraction.test.ts

@@ -94,6 +94,25 @@ vi.mock('@memberjunction/core', () => ({
   SetProvider: vi.fn(),
 }));
 
+// `resolveDbPlatformFromEnv` lives in `@memberjunction/generic-database-provider`
+// (server-only — it touches `process.env`). The real package would pull in
+// AI / actions / queue transitively, which is too heavy for a unit-test mock.
+// Inline the actual implementation here so the env-var-handling tests below
+// exercise the genuine behavior (they're testing this function).
+vi.mock('@memberjunction/generic-database-provider', () => ({
+  resolveDbPlatformFromEnv: (envVarName: string = 'DB_PLATFORM'): 'sqlserver' | 'postgresql' | undefined => {
+    const raw = process.env[envVarName];
+    if (raw === undefined) return undefined;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === '') return undefined;
+    if (normalized === 'sqlserver' || normalized === 'postgresql') return normalized;
+    throw new Error(
+      `Invalid ${envVarName} value '${raw}'. Must be 'sqlserver' or 'postgresql' (case-insensitive). ` +
+        `Legacy aliases ('mssql', 'postgres', 'pg') and the legacy env var DB_TYPE are no longer supported.`,
+    );
+  },
+}));
+
 vi.mock('@memberjunction/sqlserver-dataprovider', () => ({
   SQLServerDataProvider: vi.fn(),
   SQLServerProviderConfigData: vi.fn(),
@@ -116,14 +135,14 @@ import {
   GetReadWriteProvider,
 } from '../util.js';
 
-// getDbType is a pure function in index.ts, but importing index.ts triggers
-// type-graphql. Replicate the logic here for isolated testing.
-function getDbType(): 'sqlserver' | 'postgresql' {
-  const dbType = process.env.DB_TYPE?.toLowerCase();
-  if (dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg') {
-    return 'postgresql';
-  }
-  return 'sqlserver';
+// `index.ts` exports `getDbType` but importing it triggers type-graphql at
+// module load time, which is too heavy for a unit test. Re-derive the same
+// logic here using the canonical helper from @memberjunction/global so the
+// behavior under test stays in lockstep with production.
+import { resolveDbPlatformFromEnv } from '@memberjunction/generic-database-provider';
+import type { DatabasePlatform } from '@memberjunction/core';
+function getDbType(): DatabasePlatform {
+  return resolveDbPlatformFromEnv() ?? 'sqlserver';
 }
 
 // --------------------------------------------------------------------------
@@ -196,52 +215,80 @@ describe('Database Abstraction Layer', () => {
   });
 
   // ======================================================================
-  // 1. DB_TYPE detection
+  // 1. DB_PLATFORM detection (strict: throws on typo, DB_TYPE no longer read)
   // ======================================================================
-  describe('getDbType – DB_TYPE environment detection', () => {
-    it('should return "sqlserver" when DB_TYPE is not set', () => {
+  describe('getDbType – DB_PLATFORM env detection', () => {
+    beforeEach(() => {
+      // Clear both vars before each case. DB_PLATFORM is what the resolver
+      // reads now; DB_TYPE is cleared too so we can prove it's ignored
+      // (no silent fallback to the removed legacy var).
+      delete process.env.DB_PLATFORM;
       delete process.env.DB_TYPE;
-      expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should return "postgresql" when DB_TYPE is "postgresql"', () => {
-      process.env.DB_TYPE = 'postgresql';
-      expect(getDbType()).toBe('postgresql');
+    it('returns "sqlserver" by default when DB_PLATFORM is not set', () => {
+      expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should return "postgresql" when DB_TYPE is "postgres"', () => {
-      process.env.DB_TYPE = 'postgres';
+    it('returns "postgresql" when DB_PLATFORM is the canonical "postgresql"', () => {
+      process.env.DB_PLATFORM = 'postgresql';
       expect(getDbType()).toBe('postgresql');
     });
 
-    it('should return "postgresql" when DB_TYPE is "pg"', () => {
-      process.env.DB_TYPE = 'pg';
-      expect(getDbType()).toBe('postgresql');
+    it('returns "sqlserver" when DB_PLATFORM is the canonical "sqlserver"', () => {
+      process.env.DB_PLATFORM = 'sqlserver';
+      expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should be case-insensitive for DB_TYPE values', () => {
-      process.env.DB_TYPE = 'PostgreSQL';
+    it('is case-insensitive for canonical values', () => {
+      process.env.DB_PLATFORM = 'PostgreSQL';
       expect(getDbType()).toBe('postgresql');
 
-      process.env.DB_TYPE = 'POSTGRES';
-      expect(getDbType()).toBe('postgresql');
-
-      process.env.DB_TYPE = 'PG';
-      expect(getDbType()).toBe('postgresql');
+      process.env.DB_PLATFORM = 'SQLSERVER';
+      expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should return "sqlserver" for unrecognized DB_TYPE values', () => {
-      process.env.DB_TYPE = 'mysql';
+    it('treats empty-string DB_PLATFORM as unset (returns "sqlserver" default)', () => {
+      process.env.DB_PLATFORM = '';
       expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should return "sqlserver" for empty-string DB_TYPE', () => {
-      process.env.DB_TYPE = '';
+    it('treats whitespace-only DB_PLATFORM as unset', () => {
+      process.env.DB_PLATFORM = '   ';
       expect(getDbType()).toBe('sqlserver');
     });
 
-    it('should return "sqlserver" when DB_TYPE is "sqlserver"', () => {
-      process.env.DB_TYPE = 'sqlserver';
+    it('throws on legacy alias "mssql"', () => {
+      process.env.DB_PLATFORM = 'mssql';
+      expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM value 'mssql'/);
+    });
+
+    it('throws on legacy alias "postgres"', () => {
+      process.env.DB_PLATFORM = 'postgres';
+      expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM value 'postgres'/);
+    });
+
+    it('throws on legacy alias "pg"', () => {
+      process.env.DB_PLATFORM = 'pg';
+      expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM value 'pg'/);
+    });
+
+    it('throws on unrecognized value "mysql"', () => {
+      process.env.DB_PLATFORM = 'mysql';
+      expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM value 'mysql'/);
+    });
+
+    it('error message names the offending env var (so callers know which one)', () => {
+      process.env.DB_PLATFORM = 'oracle';
+      expect(() => getDbType()).toThrow(
+        /Must be 'sqlserver' or 'postgresql'/,
+      );
+    });
+
+    it('ignores DB_TYPE entirely (legacy env var no longer consulted)', () => {
+      // Before strict mode, DB_TYPE was the primary, then a fallback. Now
+      // it's neither — anyone with DB_TYPE in their .env must rename it.
+      process.env.DB_TYPE = 'postgresql';
       expect(getDbType()).toBe('sqlserver');
     });
   });
@@ -487,32 +534,32 @@ describe('Database Abstraction Layer', () => {
   // 7. Context creation – database type branching in contextFunction
   // ======================================================================
   describe('Database type branching for context creation', () => {
-    it('should identify postgres when DB_TYPE is "postgresql"', () => {
-      process.env.DB_TYPE = 'postgresql';
-      const dbType = process.env.DB_TYPE?.toLowerCase();
-      const isPostgres = dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg';
-      expect(isPostgres).toBe(true);
+    beforeEach(() => {
+      delete process.env.DB_PLATFORM;
+      delete process.env.DB_TYPE;
     });
 
-    it('should identify postgres when DB_TYPE is "pg"', () => {
-      process.env.DB_TYPE = 'pg';
-      const dbType = process.env.DB_TYPE?.toLowerCase();
-      const isPostgres = dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg';
-      expect(isPostgres).toBe(true);
+    // The branching logic in context creation goes through the same
+    // canonical helper that getDbType() uses, so all callers see one
+    // consistent platform value.
+    it('identifies postgres when DB_PLATFORM is "postgresql"', () => {
+      process.env.DB_PLATFORM = 'postgresql';
+      expect(getDbType() === 'postgresql').toBe(true);
     });
 
-    it('should not identify postgres when DB_TYPE is "sqlserver"', () => {
-      process.env.DB_TYPE = 'sqlserver';
-      const dbType = process.env.DB_TYPE?.toLowerCase();
-      const isPostgres = dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg';
-      expect(isPostgres).toBe(false);
+    it('throws (does not silently downgrade) on legacy alias "pg"', () => {
+      process.env.DB_PLATFORM = 'pg';
+      expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM/);
     });
 
-    it('should not identify postgres when DB_TYPE is undefined', () => {
-      delete process.env.DB_TYPE;
-      const dbType = process.env.DB_TYPE?.toLowerCase();
-      const isPostgres = dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg';
-      expect(isPostgres).toBe(false);
+    it('does not identify postgres when DB_PLATFORM is "sqlserver"', () => {
+      process.env.DB_PLATFORM = 'sqlserver';
+      expect(getDbType() === 'postgresql').toBe(false);
+    });
+
+    it('does not identify postgres when DB_PLATFORM is undefined', () => {
+      delete process.env.DB_PLATFORM;
+      expect(getDbType() === 'postgresql').toBe(false);
     });
   });
 
@@ -793,23 +840,38 @@ describe('Database Abstraction Layer', () => {
   // 14. getDbType return type
   // ======================================================================
   describe('getDbType return type compliance', () => {
-    it('should return a value matching the DatabasePlatform union type', () => {
+    beforeEach(() => {
+      delete process.env.DB_PLATFORM;
       delete process.env.DB_TYPE;
+    });
+
+    it('returns a value matching the DatabasePlatform union type when unset', () => {
       const result = getDbType();
       const validValues: string[] = ['sqlserver', 'postgresql'];
       expect(validValues).toContain(result);
     });
 
-    it('should always return one of the two valid DatabasePlatform values', () => {
-      const testValues = ['', 'oracle', 'mysql', 'sqlite', 'mongodb', undefined];
-      for (const val of testValues) {
+    it('returns a canonical value or throws — never returns a non-canonical string', () => {
+      // Strict contract: getDbType() either returns one of the two canonical
+      // platform names, or throws. There's no third "fallback to default"
+      // outcome for non-empty unrecognized values — silent fallback was the
+      // bug we're eliminating.
+      const validReturns = ['sqlserver', 'postgresql'];
+
+      // Unset / empty / whitespace return the default
+      for (const val of [undefined, '', '   ']) {
         if (val === undefined) {
-          delete process.env.DB_TYPE;
+          delete process.env.DB_PLATFORM;
         } else {
-          process.env.DB_TYPE = val;
+          process.env.DB_PLATFORM = val;
         }
-        const result = getDbType();
-        expect(['sqlserver', 'postgresql']).toContain(result);
+        expect(validReturns).toContain(getDbType());
+      }
+
+      // Unrecognized non-empty values throw
+      for (const val of ['oracle', 'mysql', 'sqlite', 'mongodb']) {
+        process.env.DB_PLATFORM = val;
+        expect(() => getDbType()).toThrow(/Invalid DB_PLATFORM/);
       }
     });
   });

package/src/auth/newUsers.ts

@@ -110,9 +110,16 @@ export class NewUserBase {
                         LogStatus(`Created User Application ${application.Name} for new user ${user.Name}`);
 
                         const rv: RunView = new RunView();
+                        // Boolean literal goes through the active provider's dialect:
+                        //   SQL Server emits `= 1`, PostgreSQL emits `= TRUE`.
+                        // This keeps the filter server-side (no client-side `.filter()`
+                        // pass) and uses the single source-of-truth helper instead of
+                        // hardcoded SQL that is correct on one dialect but breaks on
+                        // the other.
+                        const trueLit = provider.Dialect.BooleanLiteral(true);
                         const rvResult: RunViewResult<MJApplicationEntityEntityType> = await rv.RunView({
                             EntityName: 'MJ: Application Entities',
-                            ExtraFilter: `ApplicationID = '${application.ID}' and DefaultForNewUser = 1`,
+                            ExtraFilter: `ApplicationID = '${application.ID}' AND DefaultForNewUser = ${trueLit}`,
                         }, contextUser);
 
                         if(!rvResult.Success){
@@ -120,9 +127,11 @@ export class NewUserBase {
                             continue;
                         }
 
-                        LogStatus(`Creating ${rvResult.Results.length} User Application Entities for User Application ${application.Name} for new user ${user.Name}`);
+                        const defaultForNewUserEntities = rvResult.Results;
 
-                        for(const [index, appEntity] of rvResult.Results.entries()){
+                        LogStatus(`Creating ${defaultForNewUserEntities.length} User Application Entities for User Application ${application.Name} for new user ${user.Name}`);
+
+                        for(const [index, appEntity] of defaultForNewUserEntities.entries()){
                             const userAppEntity: MJUserApplicationEntityEntity = await md.GetEntityObject<MJUserApplicationEntityEntity>('MJ: User Application Entities', contextUser);
                             userAppEntity.NewRecord();
                             userAppEntity.UserApplicationID = userApplication.ID;

package/src/context.ts

@@ -18,8 +18,27 @@ import { DatabaseProviderBase } from '@memberjunction/core';
 import { SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { Metadata } from '@memberjunction/core';
 import { UUIDsEqual } from '@memberjunction/global';
+import { resolveDbPlatformFromEnv } from '@memberjunction/generic-database-provider';
 import { GetAPIKeyEngine } from '@memberjunction/api-keys';
 
+/**
+ * Renders a value for one-line console logging without Node's `[Object]` truncation.
+ * Arrays keep their structure; non-array objects collapse to JSON, truncated at `maxLen`.
+ * Objects whose JSON exceeds `maxLen` and contain nested structure are recursed into so
+ * outer keys remain visible.
+ */
+function shortenForLog(value: unknown, maxLen = 300): unknown {
+  if (value === null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) return value.map((v) => shortenForLog(v, maxLen));
+  const json = JSON.stringify(value);
+  if (json.length <= maxLen) return json;
+  const result: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    result[k] = shortenForLog(v, maxLen);
+  }
+  return result;
+}
+
 const verifyAsync = async (issuer: string, token: string): Promise<jwt.JwtPayload> =>
   new Promise((resolve, reject) => {
     const options = getValidationOptions(issuer);
@@ -323,7 +342,7 @@ export const contextFunction =
     const reqAny = req as any;
     const operationName: string | undefined = reqAny.body?.operationName;
     if (operationName !== 'IntrospectionQuery') {
-      console.log({ operationName, variables: reqAny.body?.variables || undefined });
+      console.dir({ operationName, variables: shortenForLog(reqAny.body?.variables) }, { depth: null, breakLength: 200 });
     }
 
     // Auth already happened in the unified auth middleware — just read the result
@@ -356,8 +375,7 @@ async function createPerRequestProviders(
   dataSource: sql.ConnectionPool,
   dataSources: DataSourceInfo[]
 ): Promise<Array<{ provider: DatabaseProviderBase; type: 'Read-Write' | 'Read-Only' }>> {
-  const dbType = process.env.DB_TYPE?.toLowerCase();
-  const isPostgres = dbType === 'postgresql' || dbType === 'postgres' || dbType === 'pg';
+  const isPostgres = resolveDbPlatformFromEnv() === 'postgresql';
 
   let p: DatabaseProviderBase;
   if (isPostgres) {