@dbml/connector 3.13.9-alpha.0 → 3.14.0

package/dist/connectors/bigqueryConnector.js

@@ -4,16 +4,32 @@ exports.fetchSchemaJson = fetchSchemaJson;
 const bigquery_1 = require("@google-cloud/bigquery");
 const credential_loader_1 = require("../utils/credential-loader");
 const helpers_1 = require("../utils/helpers");
+// BigQuery client authentication strategy:
+// 1. Start with environment/default authentication:
+//    - GOOGLE_APPLICATION_CREDENTIALS env variable (service account key file)
+//    - Application Default Credentials (gcloud auth application-default login)
+//
+// 2. Override with explicitly provided properties:
+//    - If projectId is provided, override the default project
+//    - If credentials (clientEmail + privateKey) provided, override auth method
+//    - If datasets specified in config, fetch only those datasets
 async function connectBigQuery(credential) {
-    const client = new bigquery_1.BigQuery({
-        projectId: credential.projectId,
-        credentials: {
-            private_key: credential.credentials.privateKey,
+    const config = {};
+    // Override project if explicitly provided
+    if (credential?.projectId) {
+        config.projectId = credential.projectId;
+    }
+    // Override credentials if both email and key are provided
+    if (credential?.credentials?.clientEmail && credential?.credentials?.privateKey) {
+        config.credentials = {
             client_email: credential.credentials.clientEmail,
-        },
-    });
+            private_key: credential.credentials.privateKey,
+        };
+    }
+    // Create client with merged config
+    const client = new bigquery_1.BigQuery(config);
     try {
-        const query = `SELECT CURRENT_DATE() as today`;
+        const query = 'SELECT CURRENT_DATE() as today';
         await client.query(query);
         return client;
     }
@@ -30,6 +46,7 @@ function getDbDefault(columnDefault, defaultValueType) {
     }
     if (defaultValueType === 'string') {
         // bigquery store the double qoutes and quotes at the end and the beginning of the string: "string" or 'string'
+        // eslint-disable-next-line no-useless-escape
         return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType };
     }
     return { value: columnDefault, type: defaultValueType };
@@ -53,17 +70,17 @@ function generateField(row) {
     return field;
 }
 async function generateTablesAndFields(client, projectId, datasetId) {
-    const tableName = `${projectId}.${datasetId}`;
+    const tableNameToFetch = `${projectId}.${datasetId}`;
     const query = `
     with
       table_comments as (
         select table_schema, table_name, option_value as description
-        from ${tableName}.INFORMATION_SCHEMA.TABLE_OPTIONS
+        from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLE_OPTIONS
         where option_name = 'description'
       ),
       column_comments as (
         select column_name, table_schema, table_name, description
-        from ${tableName}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
+        from ${tableNameToFetch}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
         where column_name = field_path
       )
     select
@@ -87,8 +104,8 @@ async function generateTablesAndFields(client, projectId, datasetId) {
         WHEN c.column_default = "NULL" THEN NULL
         ELSE 'expression'
       END AS columnDefaultType
-    from ${tableName}.INFORMATION_SCHEMA.TABLES t
-    join ${tableName}.INFORMATION_SCHEMA.COLUMNS c
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLES t
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.COLUMNS c
     on
       t.table_schema = c.table_schema
       and t.table_name = c.table_name
@@ -120,15 +137,15 @@ async function generateTablesAndFields(client, projectId, datasetId) {
     };
 }
 async function generateIndexes(client, projectId, datasetId) {
-    const tableName = `${projectId}.${datasetId}`;
+    const tableNameToFetch = `${projectId}.${datasetId}`;
     const query = `
     select
       s.index_schema as indexSchema,
       s.table_name as tableName,
       s.index_name as indexName,
       string_agg(sc.index_column_name, ', ') as indexColumnNames
-    from ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEXES s
-    join ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEX_COLUMNS sc
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.SEARCH_INDEXES s
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.SEARCH_INDEX_COLUMNS sc
     on
       s.index_schema = sc.index_schema
       and s.table_name = sc.table_name
@@ -140,7 +157,7 @@ async function generateIndexes(client, projectId, datasetId) {
     const [queryResult] = await client.query(query);
     const indexMap = {};
     queryResult.forEach((row) => {
-        const { indexSchema, tableName, indexName, indexColumnNames } = row;
+        const { indexSchema, tableName, indexName, indexColumnNames, } = row;
         const indexColumns = indexColumnNames.split(', ').map((column) => {
             return {
                 type: 'column',
@@ -163,7 +180,7 @@ async function generateIndexes(client, projectId, datasetId) {
     return indexMap;
 }
 async function generateTableConstraints(client, projectId, datasetId) {
-    const tableName = `${projectId}.${datasetId}`;
+    const tableNameToFetch = `${projectId}.${datasetId}`;
     const query = `
     select
       tc.table_schema as tableSchema,
@@ -171,8 +188,8 @@ async function generateTableConstraints(client, projectId, datasetId) {
       tc.constraint_name as constraintName,
       string_agg(kcu.column_name, ', ') as columnNames,
       count(kcu.column_name) as columnCount,
-    from ${tableName}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-    join ${tableName}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
     on
       tc.table_schema = kcu.table_schema
       and tc.table_name = kcu.table_name
@@ -198,7 +215,7 @@ async function generateTableConstraints(client, projectId, datasetId) {
     });
     const compositePrimaryKeyMap = {};
     compositePrimaryKeyList.forEach((compositeKey) => {
-        const { tableSchema, tableName, constraintName, columnNames } = compositeKey;
+        const { tableSchema, tableName, constraintName, columnNames, } = compositeKey;
         const indexColumns = columnNames.split(', ').map((column) => {
             return {
                 type: 'column',
@@ -260,12 +277,14 @@ async function fetchSchemaJson(keyFilename) {
     const querySchemaPromises = datasetIdList.map((dataset) => fetchSchemaJsonByDataset(client, projectId, dataset));
     const databaseSchemaRes = await Promise.all(querySchemaPromises);
     const res = databaseSchemaRes.reduce((acc, dbSchema) => {
-        const { tables, fields, indexes, tableConstraints } = dbSchema;
+        const { tables, fields, indexes, tableConstraints, } = dbSchema;
         acc.tables = (0, helpers_1.mergeTables)(acc.tables, tables);
         acc.fields = (0, helpers_1.mergeFieldDictionary)(acc.fields, fields);
         acc.indexes = (0, helpers_1.mergeIndexDictionary)(acc.indexes, indexes);
         acc.tableConstraints = (0, helpers_1.mergeTableConstraintDictionary)(acc.tableConstraints, tableConstraints);
         return acc;
-    }, { tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [] });
+    }, {
+        tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [],
+    });
     return res;
 }

package/dist/connectors/types.d.ts

@@ -80,8 +80,8 @@ interface DatabaseSchema {
     indexes: IndexesDictionary;
 }
 interface BigQueryCredentials {
-    projectId: string;
-    credentials: {
+    projectId?: string;
+    credentials?: {
         clientEmail: string;
         privateKey: string;
     };

package/dist/utils/credential-loader.js

@@ -19,30 +19,35 @@ function parseBigQueryCredential(credentialString) {
     try {
         const credentialJson = JSON.parse(credentialString);
         const { project_id: projectId, client_email: clientEmail, private_key: privateKey, datasets, } = credentialJson;
-        if (typeof projectId !== 'string' || !projectId || !projectId.trim()) {
-            throw new Error('project_id must be a non-empty string');
-        }
-        if (typeof clientEmail !== 'string' || !clientEmail || !clientEmail.trim()) {
-            throw new Error('client_email must be a non-empty string');
-        }
-        if (typeof privateKey !== 'string' || !privateKey || !privateKey.trim()) {
-            throw new Error('private_key must be a non-empty string');
-        }
-        if (typeof clientEmail !== 'string' || !clientEmail || !clientEmail.trim()) {
-            throw new Error('client_email must be a non-empty string');
-        }
         // valid datasets: ['dataset_1', 'dataset_2']
         const parsedDatasets = !Array.isArray(datasets)
             ? []
             : datasets.filter((dataset) => typeof dataset === 'string');
-        return {
-            projectId,
-            credentials: {
-                clientEmail,
-                privateKey,
-            },
+        const parsedCredentials = {
             datasets: parsedDatasets,
         };
+        // Validate and add projectId if provided
+        if (projectId !== undefined) {
+            if (typeof projectId !== 'string' || !projectId || !projectId.trim()) {
+                throw new Error('project_id must be a non-empty string when provided');
+            }
+            parsedCredentials.projectId = projectId;
+        }
+        // Validate and add credentials if provided
+        // Note: If one credential field is provided, both must be provided
+        if (clientEmail !== undefined || privateKey !== undefined) {
+            if (!clientEmail || typeof clientEmail !== 'string' || !clientEmail.trim()) {
+                throw new Error('client_email must be a non-empty string when credentials are provided');
+            }
+            if (!privateKey || typeof privateKey !== 'string' || !privateKey.trim()) {
+                throw new Error('private_key must be a non-empty string when credentials are provided');
+            }
+            parsedCredentials.credentials = {
+                clientEmail,
+                privateKey,
+            };
+        }
+        return parsedCredentials;
     }
     catch (error) {
         if (error instanceof SyntaxError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbml/connector",
-  "version": "3.13.9-alpha.0",
+  "version": "3.14.0",
   "description": "This package was created to fetch the schema JSON from many kind of databases.",
   "author": "huy.phung.sw@gmail.com",
   "license": "MIT",
@@ -44,5 +44,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "330b32307bc949fbcd948455af53995eeb70e17c"
+  "gitHead": "a3be772822c217e0b8afa975e90fa54b81d38276"
 }

package/src/connectors/bigqueryConnector.ts

@@ -1,4 +1,4 @@
-import { BigQuery } from '@google-cloud/bigquery';
+import { BigQuery, BigQueryOptions } from '@google-cloud/bigquery';
 import { loadCredentialFromFile, parseBigQueryCredential } from '../utils/credential-loader';
 import {
   getIntersection,
@@ -21,17 +21,36 @@ import {
   TableConstraintsDictionary,
 } from './types';
 
-async function connectBigQuery(credential: BigQueryCredentials): Promise<BigQuery> {
-  const client = new BigQuery({
-    projectId: credential.projectId,
-    credentials: {
-      private_key: credential.credentials.privateKey,
+// BigQuery client authentication strategy:
+// 1. Start with environment/default authentication:
+//    - GOOGLE_APPLICATION_CREDENTIALS env variable (service account key file)
+//    - Application Default Credentials (gcloud auth application-default login)
+//
+// 2. Override with explicitly provided properties:
+//    - If projectId is provided, override the default project
+//    - If credentials (clientEmail + privateKey) provided, override auth method
+//    - If datasets specified in config, fetch only those datasets
+async function connectBigQuery (credential: BigQueryCredentials): Promise<BigQuery> {
+  const config: BigQueryOptions = {};
+
+  // Override project if explicitly provided
+  if (credential?.projectId) {
+    config.projectId = credential.projectId;
+  }
+
+  // Override credentials if both email and key are provided
+  if (credential?.credentials?.clientEmail && credential?.credentials?.privateKey) {
+    config.credentials = {
       client_email: credential.credentials.clientEmail,
-    },
-  });
+      private_key: credential.credentials.privateKey,
+    };
+  }
+
+  // Create client with merged config
+  const client = new BigQuery(config);
 
   try {
-    const query = `SELECT CURRENT_DATE() as today`;
+    const query = 'SELECT CURRENT_DATE() as today';
     await client.query(query);
     return client;
   } catch (error) {
@@ -43,9 +62,9 @@ async function connectBigQuery(credential: BigQueryCredentials): Promise<BigQuer
   }
 }
 
-function getDbDefault(
+function getDbDefault (
   columnDefault: string,
-  defaultValueType: DefaultType | null
+  defaultValueType: DefaultType | null,
 ): DefaultInfo | null {
   if (defaultValueType === null) {
     return null;
@@ -53,13 +72,14 @@ function getDbDefault(
 
   if (defaultValueType === 'string') {
     // bigquery store the double qoutes and quotes at the end and the beginning of the string: "string" or 'string'
-    return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType }
+    // eslint-disable-next-line no-useless-escape
+    return { value: columnDefault.slice(1, -1).replaceAll("'", "\'"), type: defaultValueType };
   }
 
   return { value: columnDefault, type: defaultValueType };
 }
 
-function generateField(row: any): Field {
+function generateField (row: any): Field {
   const {
     columnName,
     isNullable,
@@ -88,26 +108,26 @@ function generateField(row: any): Field {
   return field;
 }
 
-async function generateTablesAndFields(
+async function generateTablesAndFields (
   client: BigQuery,
   projectId: string,
-  datasetId: string
+  datasetId: string,
 ): Promise<{
   tables: Table[];
   fieldMap: FieldsDictionary;
 }> {
-  const tableName = `${projectId}.${datasetId}`;
+  const tableNameToFetch = `${projectId}.${datasetId}`;
 
   const query = `
     with
       table_comments as (
         select table_schema, table_name, option_value as description
-        from ${tableName}.INFORMATION_SCHEMA.TABLE_OPTIONS
+        from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLE_OPTIONS
         where option_name = 'description'
       ),
       column_comments as (
         select column_name, table_schema, table_name, description
-        from ${tableName}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
+        from ${tableNameToFetch}.INFORMATION_SCHEMA.COLUMN_FIELD_PATHS
         where column_name = field_path
       )
     select
@@ -131,8 +151,8 @@ async function generateTablesAndFields(
         WHEN c.column_default = "NULL" THEN NULL
         ELSE 'expression'
       END AS columnDefaultType
-    from ${tableName}.INFORMATION_SCHEMA.TABLES t
-    join ${tableName}.INFORMATION_SCHEMA.COLUMNS c
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLES t
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.COLUMNS c
     on
       t.table_schema = c.table_schema
       and t.table_name = c.table_name
@@ -172,12 +192,12 @@ async function generateTablesAndFields(
   };
 }
 
-async function generateIndexes(
+async function generateIndexes (
   client: BigQuery,
   projectId: string,
-  datasetId: string
+  datasetId: string,
 ): Promise<IndexesDictionary> {
-  const tableName = `${projectId}.${datasetId}`;
+  const tableNameToFetch = `${projectId}.${datasetId}`;
 
   const query = `
     select
@@ -185,8 +205,8 @@ async function generateIndexes(
       s.table_name as tableName,
       s.index_name as indexName,
       string_agg(sc.index_column_name, ', ') as indexColumnNames
-    from ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEXES s
-    join ${tableName}.INFORMATION_SCHEMA.SEARCH_INDEX_COLUMNS sc
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.SEARCH_INDEXES s
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.SEARCH_INDEX_COLUMNS sc
     on
       s.index_schema = sc.index_schema
       and s.table_name = sc.table_name
@@ -201,7 +221,9 @@ async function generateIndexes(
   const indexMap: IndexesDictionary = {};
 
   queryResult.forEach((row) => {
-    const { indexSchema, tableName, indexName, indexColumnNames } = row;
+    const {
+      indexSchema, tableName, indexName, indexColumnNames,
+    } = row;
 
     const indexColumns = indexColumnNames.split(', ').map((column: string) => {
       return {
@@ -227,15 +249,15 @@ async function generateIndexes(
   return indexMap;
 }
 
-async function generateTableConstraints(
+async function generateTableConstraints (
   client: BigQuery,
   projectId: string,
-  datasetId: string
+  datasetId: string,
 ): Promise<{
   inlinePrimaryKeyMap: TableConstraintsDictionary;
   compositePrimaryKeyMap: IndexesDictionary;
 }> {
-  const tableName = `${projectId}.${datasetId}`;
+  const tableNameToFetch = `${projectId}.${datasetId}`;
 
   const query = `
     select
@@ -244,8 +266,8 @@ async function generateTableConstraints(
       tc.constraint_name as constraintName,
       string_agg(kcu.column_name, ', ') as columnNames,
       count(kcu.column_name) as columnCount,
-    from ${tableName}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-    join ${tableName}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+    from ${tableNameToFetch}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+    join ${tableNameToFetch}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
     on
       tc.table_schema = kcu.table_schema
       and tc.table_name = kcu.table_name
@@ -258,10 +280,10 @@ async function generateTableConstraints(
   const [queryResult] = await client.query(query);
 
   const inlinePrimaryKeyList = queryResult.filter(
-    (row) => row.columnCount && row.columnCount === 1
+    (row) => row.columnCount && row.columnCount === 1,
   );
   const compositePrimaryKeyList = queryResult.filter(
-    (row) => row.columnCount && row.columnCount > 1
+    (row) => row.columnCount && row.columnCount > 1,
   );
 
   const inlinePrimaryKeyMap: TableConstraintsDictionary = {};
@@ -283,7 +305,9 @@ async function generateTableConstraints(
 
   const compositePrimaryKeyMap: IndexesDictionary = {};
   compositePrimaryKeyList.forEach((compositeKey) => {
-    const { tableSchema, tableName, constraintName, columnNames } = compositeKey;
+    const {
+      tableSchema, tableName, constraintName, columnNames,
+    } = compositeKey;
 
     const indexColumns = columnNames.split(', ').map((column: string) => {
       return {
@@ -314,7 +338,7 @@ async function generateTableConstraints(
   };
 }
 
-async function validateDatasetIdList(client: BigQuery, datasetIdList: string[]): Promise<string[]> {
+async function validateDatasetIdList (client: BigQuery, datasetIdList: string[]): Promise<string[]> {
   const [datasets] = await client.getDatasets();
 
   const rawDatasetIdList = datasets.map((dataset) => dataset.id).filter((id) => id) as string[];
@@ -326,10 +350,10 @@ async function validateDatasetIdList(client: BigQuery, datasetIdList: string[]):
   return getIntersection(datasetIdList, rawDatasetIdList);
 }
 
-async function fetchSchemaJsonByDataset(
+async function fetchSchemaJsonByDataset (
   client: BigQuery,
   projectId: string,
-  datasetId: string
+  datasetId: string,
 ): Promise<DatabaseSchema> {
   const res = await Promise.all([
     generateTablesAndFields(client, projectId, datasetId),
@@ -351,7 +375,7 @@ async function fetchSchemaJsonByDataset(
   };
 }
 
-async function fetchSchemaJson(keyFilename: string): Promise<DatabaseSchema> {
+async function fetchSchemaJson (keyFilename: string): Promise<DatabaseSchema> {
   const rawCredential = await loadCredentialFromFile(keyFilename);
   const credentialJson = parseBigQueryCredential(rawCredential);
   const client = await connectBigQuery(credentialJson);
@@ -359,14 +383,15 @@ async function fetchSchemaJson(keyFilename: string): Promise<DatabaseSchema> {
   const projectId = await client.getProjectId();
   const datasetIdList = await validateDatasetIdList(client, credentialJson.datasets);
 
-  const querySchemaPromises = datasetIdList.map((dataset) =>
-    fetchSchemaJsonByDataset(client, projectId, dataset)
-  );
+  const querySchemaPromises = datasetIdList.map((dataset) => fetchSchemaJsonByDataset(client, projectId, dataset));
 
   const databaseSchemaRes = await Promise.all(querySchemaPromises);
 
-  const res = databaseSchemaRes.reduce((acc, dbSchema) => {
-      const { tables, fields, indexes, tableConstraints } = dbSchema;
+  const res = databaseSchemaRes.reduce(
+    (acc, dbSchema) => {
+      const {
+        tables, fields, indexes, tableConstraints,
+      } = dbSchema;
 
       acc.tables = mergeTables(acc.tables, tables);
       acc.fields = mergeFieldDictionary(acc.fields, fields);
@@ -375,7 +400,9 @@ async function fetchSchemaJson(keyFilename: string): Promise<DatabaseSchema> {
 
       return acc;
     },
-    { tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [] }
+    {
+      tables: [], fields: {}, tableConstraints: {}, indexes: {}, refs: [], enums: [],
+    },
   );
 
   return res;

package/src/connectors/types.ts

@@ -100,8 +100,8 @@ interface DatabaseSchema {
 }
 
 interface BigQueryCredentials {
-  projectId: string,
-  credentials: {
+  projectId?: string,
+  credentials?: {
     clientEmail: string,
     privateKey: string,
   },

package/src/utils/credential-loader.ts

@@ -1,7 +1,7 @@
 import { readFile } from 'fs/promises';
 import { BigQueryCredentials } from '../connectors/types';
 
-export async function loadCredentialFromFile(filename: string): Promise<string> {
+export async function loadCredentialFromFile (filename: string): Promise<string> {
   try {
     const data = await readFile(filename, { encoding: 'utf8' });
     return data;
@@ -14,7 +14,7 @@ export async function loadCredentialFromFile(filename: string): Promise<string>
   }
 }
 
-export function parseBigQueryCredential(credentialString: string): BigQueryCredentials {
+export function parseBigQueryCredential (credentialString: string): BigQueryCredentials {
   try {
     const credentialJson = JSON.parse(credentialString);
 
@@ -25,35 +25,41 @@ export function parseBigQueryCredential(credentialString: string): BigQueryCrede
       datasets,
     } = credentialJson;
 
-    if (typeof projectId !== 'string' || !projectId || !projectId.trim()) {
-      throw new Error('project_id must be a non-empty string');
-    }
+    // valid datasets: ['dataset_1', 'dataset_2']
+    const parsedDatasets = !Array.isArray(datasets)
+      ? []
+      : datasets.filter((dataset) => typeof dataset === 'string');
 
-    if (typeof clientEmail !== 'string' || !clientEmail || !clientEmail.trim()) {
-      throw new Error('client_email must be a non-empty string');
-    }
+    const parsedCredentials: BigQueryCredentials = {
+      datasets: parsedDatasets,
+    };
 
-    if (typeof privateKey !== 'string' || !privateKey || !privateKey.trim()) {
-      throw new Error('private_key must be a non-empty string');
+    // Validate and add projectId if provided
+    if (projectId !== undefined) {
+      if (typeof projectId !== 'string' || !projectId || !projectId.trim()) {
+        throw new Error('project_id must be a non-empty string when provided');
+      }
+      parsedCredentials.projectId = projectId;
     }
 
-    if (typeof clientEmail !== 'string' || !clientEmail || !clientEmail.trim()) {
-      throw new Error('client_email must be a non-empty string');
-    }
+    // Validate and add credentials if provided
+    // Note: If one credential field is provided, both must be provided
+    if (clientEmail !== undefined || privateKey !== undefined) {
+      if (!clientEmail || typeof clientEmail !== 'string' || !clientEmail.trim()) {
+        throw new Error('client_email must be a non-empty string when credentials are provided');
+      }
 
-    // valid datasets: ['dataset_1', 'dataset_2']
-    const parsedDatasets = !Array.isArray(datasets)
-      ? []
-      : datasets.filter((dataset) => typeof dataset === 'string');
+      if (!privateKey || typeof privateKey !== 'string' || !privateKey.trim()) {
+        throw new Error('private_key must be a non-empty string when credentials are provided');
+      }
 
-    return {
-      projectId,
-      credentials: {
+      parsedCredentials.credentials = {
         clientEmail,
         privateKey,
-      },
-      datasets: parsedDatasets,
-    };
+      };
+    }
+
+    return parsedCredentials;
   } catch (error) {
     if (error instanceof SyntaxError) {
       throw new Error('Credentials must be in JSON format');