@claryai/cli 0.1.0

package/dist/dbt/models.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompiledModels = exports.findAndUpdateModelYaml = exports.isDocBlock = exports.getWarehouseTableForModel = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const execa_1 = tslib_1.__importDefault(require("execa"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const path = tslib_1.__importStar(require("path"));
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const schema_1 = require("./schema");
+const getWarehouseTableForModel = async ({ model, warehouseClient, preserveColumnCase, }) => {
+    const tableRef = {
+        database: model.database,
+        schema: model.schema,
+        table: model.alias || model.name,
+    };
+    const catalog = await warehouseClient.getCatalog([tableRef]);
+    const table = catalog[tableRef.database]?.[tableRef.schema]?.[tableRef.table];
+    if (!table) {
+        const database = catalog[tableRef.database];
+        const schema = database?.[tableRef.schema];
+        const missing = (database === undefined && `database ${tableRef.database}`) ||
+            (schema === undefined && `schema ${tableRef.schema}`) ||
+            (table === undefined && `table ${tableRef.table}`);
+        throw new common_1.ParseError(`Expected to find materialised model at ${tableRef.database}.${tableRef.schema}.${tableRef.table} but couldn't find (or cannot access) ${missing}`);
+    }
+    return Object.entries(table).reduce((accumulator, [key, value]) => {
+        const columnName = preserveColumnCase ? key : key.toLowerCase();
+        accumulator[columnName] = value;
+        return accumulator;
+    }, {});
+};
+exports.getWarehouseTableForModel = getWarehouseTableForModel;
+// Check if we should use dbt 1.10+ metadata structure
+const wrapInConfig = (dbtVersion, meta) => {
+    const useDbt110Metadata = dbtVersion &&
+        Object.values(common_1.SupportedDbtVersions).indexOf(dbtVersion) >=
+            Object.values(common_1.SupportedDbtVersions).indexOf(common_1.SupportedDbtVersions.V1_10);
+    return useDbt110Metadata ? { config: { meta } } : { meta };
+};
+const generateModelYml = ({ model, table, includeMeta, dbtVersion, }) => ({
+    name: model.name,
+    columns: Object.entries(table).map(([columnName, dimensionType]) => ({
+        name: columnName,
+        description: '',
+        ...(includeMeta
+            ? wrapInConfig(dbtVersion, {
+                dimension: {
+                    type: dimensionType,
+                },
+            })
+            : {}),
+    })),
+});
+const askOverwrite = async (message) => {
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'isConfirm',
+            message,
+        },
+    ]);
+    if (!answers.isConfirm) {
+        return false;
+    }
+    return true;
+};
+const isDocBlock = (text = '') => !!text.match(/{{\s*doc\(['"]\w+['"]\)\s*}}/);
+exports.isDocBlock = isDocBlock;
+const askOverwriteDescription = async (columnName, existingDescription, newDescription, assumeYes) => {
+    if (!existingDescription)
+        return newDescription || '';
+    if (!newDescription)
+        return existingDescription;
+    if (newDescription === existingDescription ||
+        (0, exports.isDocBlock)(existingDescription))
+        return existingDescription;
+    if (assumeYes)
+        return newDescription;
+    const shortDescription = `${existingDescription.substring(0, 20)}${existingDescription.length > 20 ? '...' : ''}`;
+    const overwriteMessage = `Do you want to overwrite the existing column "${columnName}" description (${shortDescription}) with a doc block?`;
+    const spinner = globalState_1.default.getActiveSpinner();
+    spinner?.stop();
+    const overwrite = await askOverwrite(overwriteMessage);
+    spinner?.start();
+    if (overwrite)
+        return newDescription;
+    return existingDescription;
+};
+const findAndUpdateModelYaml = async ({ model, table, docs, includeMeta, projectDir, projectName, assumeYes, dbtVersion, }) => {
+    const generatedModel = generateModelYml({
+        model,
+        table,
+        includeMeta,
+        dbtVersion,
+    });
+    const filenames = [];
+    const { patchPath, packageName } = model;
+    if (patchPath) {
+        const { project: expectedYamlProject, path: expectedYamlSubPath } = (0, common_1.patchPathParts)(patchPath);
+        const projectSubpath = expectedYamlProject !== projectName
+            ? path.join('dbt_packages', expectedYamlProject)
+            : '.';
+        const expectedYamlPath = path.join(projectDir, projectSubpath, expectedYamlSubPath);
+        filenames.push(expectedYamlPath);
+    }
+    const outputDir = path.dirname(path.join(packageName === projectName
+        ? '.'
+        : path.join('dbt_packages', packageName), model.originalFilePath));
+    const outputFilePath = path.join(projectDir, outputDir, `${model.name}.yml`);
+    filenames.push(outputFilePath);
+    const match = await (0, schema_1.searchForModel)({
+        modelName: model.name,
+        filenames,
+        dbtVersion,
+    });
+    if (match) {
+        const { schemaEditor } = match;
+        const docsNames = Object.values(docs).map((doc) => doc.name);
+        const existingColumns = schemaEditor.getModelColumns(model.name) ?? [];
+        const existingColumnNamesLower = existingColumns.map((c) => c.name.toLowerCase());
+        // Build a case-insensitive lookup for warehouse table columns
+        const tableLower = Object.entries(table).reduce((acc, [key, value]) => {
+            acc[key.toLowerCase()] = value;
+            return acc;
+        }, {});
+        // Update existing columns description and dimension type
+        for (const column of existingColumns) {
+            const hasDoc = docsNames.includes(column.name);
+            const newDescription = hasDoc ? `{{doc('${column.name}')}}` : '';
+            const existingDescription = column.description;
+            const existingDimensionType = column.meta?.dimension?.type;
+            const dimensionType = tableLower[column.name.toLowerCase()];
+            // eslint-disable-next-line no-await-in-loop
+            const description = await askOverwriteDescription(column.name, existingDescription, newDescription, assumeYes);
+            // Update meta if dimension type is different
+            const meta = includeMeta &&
+                dimensionType &&
+                existingDimensionType !== dimensionType
+                ? {
+                    dimension: {
+                        type: dimensionType,
+                    },
+                }
+                : undefined;
+            schemaEditor.updateColumn({
+                modelName: model.name,
+                columnName: column.name,
+                properties: {
+                    description,
+                    ...(meta ? wrapInConfig(dbtVersion, meta) : {}),
+                },
+            });
+        }
+        // Add columns that don't exist in the model (case-insensitive comparison)
+        const newColumns = generatedModel.columns.filter((c) => !existingColumnNamesLower.includes(c.name.toLowerCase()));
+        newColumns.forEach((column) => {
+            schemaEditor.addColumn(model.name, column);
+        });
+        // Delete columns that no longer exist in the warehouse (case-insensitive comparison)
+        const generatedColumnNamesLower = generatedModel.columns.map((gc) => gc.name.toLowerCase());
+        const deletedColumnNames = existingColumns
+            .filter((c) => !generatedColumnNamesLower.includes(c.name.toLowerCase()))
+            .map((c) => c.name);
+        if (deletedColumnNames.length > 0 && !globalState_1.default.isNonInteractive()) {
+            let answers = { isConfirm: assumeYes };
+            if (!assumeYes) {
+                const spinner = globalState_1.default.getActiveSpinner();
+                spinner?.stop();
+                console.error(`
+    These columns in your model ${styles.bold(model.name)} on file ${styles.bold(match.filename.split('/').slice(-1))} no longer exist in your warehouse:
+    ${deletedColumnNames.map((name) => `- ${styles.bold(name)} \n`).join('')}
+                `);
+                answers = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'isConfirm',
+                        message: `Would you like to remove them from your .yml file? `,
+                    },
+                ]);
+                spinner?.start();
+            }
+            if (answers.isConfirm) {
+                schemaEditor.removeColumns(model.name, deletedColumnNames);
+            }
+        }
+        return {
+            updatedYml: schemaEditor,
+            outputFilePath: match.filename,
+        };
+    }
+    return {
+        updatedYml: new common_1.DbtSchemaEditor('', '', dbtVersion).addModel(generatedModel),
+        outputFilePath,
+    };
+};
+exports.findAndUpdateModelYaml = findAndUpdateModelYaml;
+const getCompiledModels = async (models, args) => {
+    let allModelIds = models.map((model) => model.unique_id);
+    if (args.select || args.exclude) {
+        const spinner = globalState_1.default.startSpinner(`Filtering models`);
+        try {
+            const { stdout } = await (0, execa_1.default)('dbt', [
+                'ls',
+                ...(args.projectDir ? ['--project-dir', args.projectDir] : []),
+                ...(args.profilesDir
+                    ? ['--profiles-dir', args.profilesDir]
+                    : []),
+                ...(args.target ? ['--target', args.target] : []),
+                ...(args.profile ? ['--profile', args.profile] : []),
+                ...(args.select ? ['--select', args.select.join(' ')] : []),
+                ...(args.exclude ? ['--exclude', args.exclude.join(' ')] : []),
+                ...(args.vars ? ['--vars', args.vars] : []),
+                '--resource-type=model',
+                '--output=json',
+            ]);
+            const filteredModelIds = stdout
+                .split('\n')
+                .map((l) => l.trim())
+                .filter((l) => l.length > 0)
+                .map((l) => {
+                try {
+                    // remove prefixed time in dbt cloud cli output
+                    const lineWithoutPrefixedTime = l.replace(/^\d{2}:\d{2}:\d{2}\s*/, '');
+                    return JSON.parse(lineWithoutPrefixedTime);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((l) => l !== null)
+                .filter((model) => model.resource_type === 'model')
+                .map((model) => model.unique_id);
+            allModelIds = allModelIds.filter((modelId) => filteredModelIds.includes(modelId));
+        }
+        catch (e) {
+            console.error(styles.error(`Failed to filter models: ${e}`));
+            throw e;
+        }
+        finally {
+            spinner.stop();
+        }
+    }
+    const modelLookup = models.reduce((acc, model) => ({ ...acc, [model.unique_id]: model }), {});
+    return allModelIds.map((modelId) => ({
+        name: modelLookup[modelId].name,
+        schema: modelLookup[modelId].schema,
+        database: modelLookup[modelId].database,
+        originalFilePath: modelLookup[modelId].original_file_path,
+        patchPath: modelLookup[modelId].patch_path,
+        alias: modelLookup[modelId].alias,
+        packageName: modelLookup[modelId].package_name,
+    }));
+};
+exports.getCompiledModels = getCompiledModels;

package/dist/dbt/models.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.test.d.ts.map

package/dist/dbt/models.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.test.d.ts","sourceRoot":"","sources":["../../src/dbt/models.test.ts"],"names":[],"mappings":""}

package/dist/dbt/models.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("./models");
+describe('Models', () => {
+    describe('isDocBlock', () => {
+        test('should match all doc block variations', () => {
+            expect((0, models_1.isDocBlock)("{{doc('user_id')}}")).toBe(true); // single quote
+            expect((0, models_1.isDocBlock)('{{doc("user_id")}}')).toBe(true); // double quote
+            expect((0, models_1.isDocBlock)("{{ doc('user_id') }}")).toBe(true); // white spaces
+            expect((0, models_1.isDocBlock)("{{ doc('user_id')}}")).toBe(true); // inconsistent white space
+        });
+        test('should return false when value doesnt match doc block', () => {
+            expect((0, models_1.isDocBlock)()).toBe(false);
+            expect((0, models_1.isDocBlock)('{{ref("user_id")}}')).toBe(false);
+            expect((0, models_1.isDocBlock)("doc('user_id')")).toBe(false);
+            expect((0, models_1.isDocBlock)('my description')).toBe(false);
+        });
+    });
+});

package/dist/dbt/profile.d.ts

@@ -0,0 +1,9 @@
+import { CreateWarehouseCredentials } from '@lightdash/common';
+import { LoadProfileArgs, Target } from './types';
+export declare const loadDbtTarget: ({ profilesDir, profileName, targetName, }: LoadProfileArgs) => Promise<{
+    name: string;
+    target: Target;
+}>;
+export declare const warehouseCredentialsFromDbtTarget: (target: Target) => Promise<CreateWarehouseCredentials>;
+export declare const findDbtDefaultProfile: () => string;
+//# sourceMappingURL=profile.d.ts.map

package/dist/dbt/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/dbt/profile.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,0BAA0B,EAG7B,MAAM,mBAAmB,CAAC;AAe3B,OAAO,EAAE,eAAe,EAAY,MAAM,EAAE,MAAM,SAAS,CAAC;AAE5D,eAAO,MAAM,aAAa,GAAU,2CAIjC,eAAe,KAAG,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA8B5D,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAC1C,QAAQ,MAAM,KACf,OAAO,CAAC,0BAA0B,CAyBpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAAO,MAYxC,CAAC"}

package/dist/dbt/profile.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDbtDefaultProfile = exports.warehouseCredentialsFromDbtTarget = exports.loadDbtTarget = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const yaml = tslib_1.__importStar(require("js-yaml"));
+const os_1 = require("os");
+const path = tslib_1.__importStar(require("path"));
+const athena_1 = require("./targets/athena");
+const Bigquery_1 = require("./targets/Bigquery");
+const clickhouse_1 = require("./targets/clickhouse");
+const databricks_1 = require("./targets/databricks");
+const duckdb_1 = require("./targets/duckdb");
+const postgres_1 = require("./targets/postgres");
+const redshift_1 = require("./targets/redshift");
+const snowflake_1 = require("./targets/snowflake");
+const trino_1 = require("./targets/trino");
+const templating_1 = require("./templating");
+const loadDbtTarget = async ({ profilesDir, profileName, targetName, }) => {
+    const profilePath = path.join(profilesDir, 'profiles.yml');
+    let allProfiles;
+    try {
+        const raw = await fs_1.promises.readFile(profilePath, { encoding: 'utf8' });
+        const rendered = (0, templating_1.renderProfilesYml)(raw);
+        allProfiles = yaml.load(rendered);
+    }
+    catch (e) {
+        const msg = (0, common_1.getErrorMessage)(e);
+        throw new common_1.ParseError(`Could not find a valid profiles.yml file at ${profilePath}:\n  ${msg}`);
+    }
+    const profile = allProfiles[profileName];
+    if (!profile) {
+        throw new common_1.ParseError(`Profile ${profileName} not found in ${profilePath}`);
+    }
+    const selectedTargetName = targetName || profile.target;
+    const target = profile.outputs[selectedTargetName];
+    if (target === undefined) {
+        throw new common_1.ParseError(`Couldn't find target "${selectedTargetName}" for profile ${profileName} in profiles.yml at ${profilePath}`);
+    }
+    return {
+        name: selectedTargetName,
+        target,
+    };
+};
+exports.loadDbtTarget = loadDbtTarget;
+const warehouseCredentialsFromDbtTarget = async (target) => {
+    switch (target.type) {
+        case 'postgres':
+            return (0, postgres_1.convertPostgresSchema)(target);
+        case 'snowflake':
+            return (0, snowflake_1.convertSnowflakeSchema)(target);
+        case 'bigquery':
+            return (0, Bigquery_1.convertBigquerySchema)(target);
+        case 'redshift':
+            return (0, redshift_1.convertRedshiftSchema)(target);
+        case 'databricks':
+            return (0, databricks_1.convertDatabricksSchema)(target);
+        case 'trino':
+            return (0, trino_1.convertTrinoSchema)(target);
+        case 'clickhouse':
+            return (0, clickhouse_1.convertClickhouseSchema)(target);
+        case 'athena':
+            return (0, athena_1.convertAthenaSchema)(target);
+        case 'duckdb':
+            return (0, duckdb_1.convertDuckdbSchema)(target);
+        default:
+            throw new common_1.ParseError(`Sorry! Clary doesn't yet support ${target.type} dbt targets`);
+    }
+};
+exports.warehouseCredentialsFromDbtTarget = warehouseCredentialsFromDbtTarget;
+const findDbtDefaultProfile = () => {
+    if (process.env.DBT_PROFILES_DIR) {
+        return process.env.DBT_PROFILES_DIR;
+    }
+    // Check in Current Working Directory
+    const profilePathFromCwd = path.join(process.cwd(), 'profiles.yml');
+    try {
+        (0, fs_1.accessSync)(profilePathFromCwd, fs_1.constants.F_OK);
+        return process.cwd();
+    }
+    catch (e) {
+        return path.join((0, os_1.homedir)(), '.dbt');
+    }
+};
+exports.findDbtDefaultProfile = findDbtDefaultProfile;

package/dist/dbt/profiles.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=profiles.test.d.ts.map

package/dist/dbt/profiles.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.test.d.ts","sourceRoot":"","sources":["../../src/dbt/profiles.test.ts"],"names":[],"mappings":""}

package/dist/dbt/profiles.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const profile_1 = require("./profile");
+jest.mock('os');
+jest.mock('fs');
+jest.mock('path');
+describe('Profile', () => {
+    const { env, cwd } = process;
+    const mockAccessSync = fs.accessSync;
+    const mockHomedir = os.homedir;
+    const mockJoin = path.join;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.resetModules();
+        process.cwd = jest.fn(() => '/current/dir');
+        mockHomedir.mockReturnValue('/root');
+        mockJoin.mockImplementation((...paths) => paths.join('/'));
+        process.env = { ...env };
+    });
+    afterEach(() => {
+        process.env = env;
+        process.cwd = cwd;
+    });
+    describe('findDbtDefaultProfile', () => {
+        test('should return path from DBT_PROFILE_DIR when set', () => {
+            process.env.DBT_PROFILES_DIR = '/path/to/profiles';
+            const result = (0, profile_1.findDbtDefaultProfile)();
+            expect(result).toBe('/path/to/profiles');
+        });
+        test('should return cwd when profile.yml exists and DBT_PROFILE_DIR is undefined', () => {
+            delete process.env.DBT_PROFILES_DIR;
+            mockAccessSync.mockImplementation(() => undefined);
+            expect((0, profile_1.findDbtDefaultProfile)()).toBe('/current/dir');
+            expect(mockAccessSync).toHaveBeenCalledWith('/current/dir/profiles.yml', fs.constants.F_OK);
+        });
+        test('should return homedir when profile.yml does not exist in cwd', () => {
+            delete process.env.DBT_PROFILE_DIR;
+            mockAccessSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            expect((0, profile_1.findDbtDefaultProfile)()).toBe('/root/.dbt');
+            expect(mockAccessSync).toHaveBeenCalledWith('/current/dir/profiles.yml', fs.constants.F_OK);
+            expect(mockHomedir).toHaveBeenCalled();
+        });
+    });
+});

package/dist/dbt/schema.d.ts

@@ -0,0 +1,31 @@
+import { DbtSchemaEditor, DimensionType, SupportedDbtVersions } from '@lightdash/common';
+type YamlColumnMeta = {
+    dimension?: {
+        type?: DimensionType;
+    };
+};
+type YamlColumn = {
+    name: string;
+    description?: string;
+    meta?: YamlColumnMeta;
+};
+export type YamlModel = {
+    name: string;
+    description?: string;
+    columns?: YamlColumn[];
+};
+export type YamlSchema = {
+    version?: 2;
+    models?: YamlModel[];
+};
+type SearchForModelArgs = {
+    modelName: string;
+    filenames: string[];
+    dbtVersion?: SupportedDbtVersions;
+};
+export declare const searchForModel: ({ modelName, filenames, dbtVersion, }: SearchForModelArgs) => Promise<{
+    schemaEditor: DbtSchemaEditor;
+    filename: string;
+} | undefined>;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/dbt/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/dbt/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,eAAe,EACf,aAAa,EAEb,oBAAoB,EACvB,MAAM,mBAAmB,CAAC;AAG3B,KAAK,cAAc,GAAG;IAClB,SAAS,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,aAAa,CAAC;KACxB,CAAC;CACL,CAAC;AAEF,KAAK,UAAU,GAAG;IACd,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,cAAc,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACrB,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;CACxB,CAAC;AAgDF,KAAK,kBAAkB,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACrC,CAAC;AACF,eAAO,MAAM,cAAc,GAAU,uCAIlC,kBAAkB;;;cAepB,CAAC"}

package/dist/dbt/schema.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchForModel = void 0;
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const loadYamlSchema = async (path, dbtVersion) => {
+    try {
+        return new common_1.DbtSchemaEditor(await fs_1.promises.readFile(path, 'utf8'), path, dbtVersion);
+    }
+    catch (e) {
+        if (e instanceof common_1.ParseError) {
+            // Prefix error message with file path
+            throw new common_1.ParseError(`Couldn't parse existing yaml file at ${path}\n${e.message}`);
+        }
+        throw e;
+    }
+};
+const findModelInYaml = async ({ filename, modelName, dbtVersion, }) => {
+    try {
+        const schemaEditor = await loadYamlSchema(filename, dbtVersion);
+        if (schemaEditor.findModelByName(modelName)) {
+            return schemaEditor;
+        }
+        return undefined;
+    }
+    catch (e) {
+        if (e instanceof Error && 'code' in e && e.code === 'ENOENT') {
+            return undefined;
+        }
+        throw e;
+    }
+};
+const searchForModel = async ({ modelName, filenames, dbtVersion, }) => {
+    for await (const filename of filenames) {
+        const schemaEditor = await findModelInYaml({
+            filename,
+            modelName,
+            dbtVersion,
+        });
+        if (schemaEditor) {
+            return {
+                schemaEditor,
+                filename,
+            };
+        }
+    }
+    return undefined;
+};
+exports.searchForModel = searchForModel;

package/dist/dbt/targets/Bigquery/index.d.ts

@@ -0,0 +1,18 @@
+import { CreateBigqueryCredentials } from '@lightdash/common';
+import { JSONSchemaType } from 'ajv';
+import { Target } from '../../types';
+type BigqueryTarget = {
+    project?: string;
+    dataset: string;
+    schema: string;
+    priority?: 'interactive' | 'batch';
+    retries?: number;
+    location?: string;
+    maximum_bytes_billed?: number;
+    timeout_seconds?: number;
+    execution_project?: string;
+};
+export declare const bigqueryTargetJsonSchema: JSONSchemaType<BigqueryTarget>;
+export declare const convertBigquerySchema: (target: Target) => Promise<CreateBigqueryCredentials>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/dbt/targets/Bigquery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dbt/targets/Bigquery/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,yBAAyB,EAG5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAOrC,KAAK,cAAc,GAAG;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,cAAc,CAgDnE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAC9B,QAAQ,MAAM,KACf,OAAO,CAAC,yBAAyB,CA8DnC,CAAC"}

package/dist/dbt/targets/Bigquery/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertBigquerySchema = exports.bigqueryTargetJsonSchema = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const better_ajv_errors_1 = tslib_1.__importDefault(require("better-ajv-errors"));
+const ajv_1 = require("../../../ajv");
+const oauth_1 = require("./oauth");
+const serviceAccount_1 = require("./serviceAccount");
+exports.bigqueryTargetJsonSchema = {
+    type: 'object',
+    properties: {
+        project: {
+            type: 'string',
+            nullable: true,
+        },
+        dataset: {
+            type: 'string',
+        },
+        schema: {
+            type: 'string',
+        },
+        priority: {
+            type: 'string',
+            enum: ['interactive', 'batch'],
+            nullable: true,
+        },
+        retries: {
+            type: 'integer',
+            nullable: true,
+        },
+        location: {
+            type: 'string',
+            nullable: true,
+        },
+        maximum_bytes_billed: {
+            type: 'integer',
+            nullable: true,
+        },
+        timeout_seconds: {
+            type: 'integer',
+            nullable: true,
+        },
+        execution_project: {
+            type: 'string',
+            nullable: true,
+        },
+    },
+    required: [],
+    oneOf: [
+        {
+            required: ['dataset'],
+        },
+        {
+            required: ['schema'],
+        },
+    ],
+};
+const convertBigquerySchema = async (target) => {
+    const validate = ajv_1.ajv.compile(exports.bigqueryTargetJsonSchema);
+    if (validate(target)) {
+        let getBigqueryCredentials;
+        switch (target.method) {
+            case 'oauth':
+                getBigqueryCredentials = oauth_1.getBigqueryCredentialsFromOauth;
+                break;
+            case 'service-account':
+                getBigqueryCredentials =
+                    serviceAccount_1.getBigqueryCredentialsFromServiceAccount;
+                break;
+            case 'service-account-json':
+                getBigqueryCredentials =
+                    serviceAccount_1.getBigqueryCredentialsFromServiceAccountJson;
+                break;
+            default:
+                throw new common_1.ParseError(`BigQuery method ${target.method} is not yet supported`);
+        }
+        if (target.project === undefined && target.method !== 'oauth')
+            throw new common_1.ParseError(`BigQuery project is required for ${target.method} authentication method`);
+        const result = {
+            type: common_1.WarehouseTypes.BIGQUERY,
+            project: target.project || '',
+            dataset: target.dataset || target.schema,
+            timeoutSeconds: target.timeout_seconds,
+            priority: target.priority,
+            keyfileContents: {},
+            retries: target.retries,
+            maximumBytesBilled: target.maximum_bytes_billed,
+            location: target.location,
+            executionProject: target.execution_project,
+        };
+        const oauthOrKeyResult = await getBigqueryCredentials(target);
+        if (oauthOrKeyResult.authenticationType ===
+            common_1.BigqueryAuthenticationType.ADC) {
+            result.authenticationType = common_1.BigqueryAuthenticationType.ADC;
+        }
+        else {
+            result.keyfileContents = oauthOrKeyResult;
+        }
+        return result;
+    }
+    const errs = (0, better_ajv_errors_1.default)(exports.bigqueryTargetJsonSchema, target, validate.errors || []);
+    throw new common_1.ParseError(`Couldn't read profiles.yml file for ${target.type}:\n${errs}`);
+};
+exports.convertBigquerySchema = convertBigquerySchema;

package/dist/dbt/targets/Bigquery/oauth.d.ts

@@ -0,0 +1,2 @@
+export declare const getBigqueryCredentialsFromOauth: () => Promise<Record<string, string>>;
+//# sourceMappingURL=oauth.d.ts.map

package/dist/dbt/targets/Bigquery/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../src/dbt/targets/Bigquery/oauth.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,+BAA+B,QAAa,OAAO,CAC5D,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA8CzB,CAAC"}