@netlify/build 35.10.0 → 35.11.0

package/lib/log/messages/core_steps.d.ts

@@ -14,6 +14,16 @@ export function logFunctionsToBundle({ logs, userFunctions, userFunctionsSrc, us
     generatedFunctions: any;
     type?: string | undefined;
 }): void;
+export function logDbProvisioning({ logs, branch, context }: {
+    logs: any;
+    branch: any;
+    context: any;
+}): void;
+export function logDbMigrations({ logs, migrations, srcDir }: {
+    logs: any;
+    migrations: any;
+    srcDir: any;
+}): void;
 export function logSecretsScanSkipMessage(logs: any, msg: any): void;
 export function logSecretsScanSuccessMessage(logs: any, msg: any): void;
 export function logSecretsScanFailBuildMessage({ logs, scanResults, groupedResults, enhancedScanShouldRunInActiveMode, }: {

package/lib/log/messages/core_steps.js

@@ -90,6 +90,22 @@ export const logFunctionsToBundle = function ({ logs, userFunctions, userFunctio
     log(logs, `Packaging ${type} from ${THEME.highlightWords(userFunctionsSrc)} directory:`);
     logArray(logs, userFunctions, { indent: false });
 };
+// Print the database provisioning message
+export const logDbProvisioning = function ({ logs, branch, context }) {
+    log(logs, `Provisioning database`);
+    if (context !== 'production') {
+        log(logs, `Creating database branch for ${THEME.highlightWords(branch)}`);
+    }
+};
+// Print the list of database migrations about to be copied
+export const logDbMigrations = function ({ logs, migrations, srcDir }) {
+    if (migrations.length === 0) {
+        log(logs, `No migrations found in ${THEME.highlightWords(srcDir)} directory`);
+        return;
+    }
+    log(logs, `Loading migrations from ${THEME.highlightWords(srcDir)} directory:`);
+    logArray(logs, migrations, { indent: false });
+};
 const logModulesWithDynamicImports = ({ logs, modulesWithDynamicImports }) => {
     const externalNodeModules = modulesWithDynamicImports.map((moduleName) => `"${moduleName}"`).join(', ');
     logWarningSubHeader(logs, `The following Node.js modules use dynamic expressions to include files:`);

package/lib/plugins_core/db_setup/index.js

@@ -1,5 +1,7 @@
 import { join } from 'node:path';
+import { logDbProvisioning, logDbMigrations } from '../../log/messages/core_steps.js';
 import { getPackageJson } from '../../utils/package.js';
+import { readMigrationEntries, getMigrationNames } from './utils.js';
 const NPM_PACKAGE_NAME = '@netlify/db';
 const condition = async ({ buildDir, packagePath, featureFlags }) => {
     if (!featureFlags?.netlify_build_db_setup) {
@@ -17,8 +19,14 @@ const condition = async ({ buildDir, packagePath, featureFlags }) => {
     }
     return false;
 };
-const coreStep = async ({ api, branch, constants, context }) => {
+const coreStep = async ({ api, branch, buildDir, constants, context, logs }) => {
     const siteId = constants.SITE_ID;
+    logDbProvisioning({ logs, branch, context });
+    const entries = await readMigrationEntries(buildDir, constants.DB_MIGRATIONS_SRC);
+    const migrationNames = getMigrationNames(entries);
+    if (migrationNames.length > 0) {
+        logDbMigrations({ logs, migrations: migrationNames, srcDir: constants.DB_MIGRATIONS_SRC });
+    }
     // @ts-expect-error This is an internal method for now so it isn't typed yet.
     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
     const database = (await api.createSiteDatabase({ site_id: siteId }));
@@ -44,6 +52,6 @@ export const dbSetup = {
     coreStep,
     coreStepId: 'db_provision',
     coreStepName: 'Netlify DB setup',
-    coreStepDescription: () => 'Setup Netlify DB database',
+    coreStepDescription: () => 'Netlify DB setup',
     condition,
 };

package/lib/plugins_core/db_setup/migrations.js

@@ -1,7 +1,8 @@
-import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
+import { copyFile, mkdir } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { pathExists } from 'path-exists';
-import { validateMigrationDirs, formatValidationErrors } from './validation.js';
+import { readMigrationEntries } from './utils.js';
+import { validateMigrations, formatValidationErrors } from './validation.js';
 const condition = async ({ featureFlags, constants, buildDir }) => {
     if (!featureFlags?.netlify_build_db_setup) {
         return false;
@@ -15,15 +16,8 @@ const condition = async ({ featureFlags, constants, buildDir }) => {
 const coreStep = async ({ constants, buildDir, systemLog }) => {
     const srcDir = resolve(buildDir, constants.DB_MIGRATIONS_SRC);
     const destDir = resolve(buildDir, constants.DB_MIGRATIONS_DIST);
-    const entries = await readdir(srcDir);
-    const dirNames = [];
-    for (const entry of entries) {
-        const entryStat = await stat(join(srcDir, entry));
-        if (entryStat.isDirectory()) {
-            dirNames.push(entry);
-        }
-    }
-    if (dirNames.length === 0) {
+    const { dirNames, fileNames } = await readMigrationEntries(buildDir, constants.DB_MIGRATIONS_SRC);
+    if (dirNames.length === 0 && fileNames.length === 0) {
         systemLog('No migration directories found, skipping copy.');
         return {};
     }
@@ -34,7 +28,7 @@ const coreStep = async ({ constants, buildDir, systemLog }) => {
             existingSqlFiles.add(dirName);
         }
     }
-    const result = validateMigrationDirs(dirNames, existingSqlFiles);
+    const result = validateMigrations(dirNames, fileNames, existingSqlFiles);
     if (!result.valid) {
         const message = formatValidationErrors(result.errors);
         throw new Error(message);
@@ -44,7 +38,14 @@ const coreStep = async ({ constants, buildDir, systemLog }) => {
         await mkdir(migrationDestDir, { recursive: true });
         await copyFile(join(srcDir, dirName, 'migration.sql'), join(migrationDestDir, 'migration.sql'));
     }
-    systemLog(`Copied ${String(result.dirs.length)} migration(s) to ${destDir}`);
+    for (const fileName of result.files) {
+        const stem = fileName.replace(/\.sql$/, '');
+        const migrationDestDir = join(destDir, stem);
+        await mkdir(migrationDestDir, { recursive: true });
+        await copyFile(join(srcDir, fileName), join(migrationDestDir, 'migration.sql'));
+    }
+    const totalCount = result.dirs.length + result.files.length;
+    systemLog(`Copied ${String(totalCount)} migration(s) to ${destDir}`);
     return {};
 };
 export const copyDbMigrations = {
@@ -54,4 +55,5 @@ export const copyDbMigrations = {
     coreStepName: 'Netlify DB migrations',
     coreStepDescription: () => 'Copy database migrations to internal directory',
     condition,
+    quiet: true,
 };

package/lib/plugins_core/db_setup/utils.d.ts

@@ -0,0 +1,6 @@
+export interface MigrationEntries {
+    dirNames: string[];
+    fileNames: string[];
+}
+export declare const readMigrationEntries: (buildDir: string, migrationsSrc?: string) => Promise<MigrationEntries>;
+export declare const getMigrationNames: ({ dirNames, fileNames }: MigrationEntries) => string[];

package/lib/plugins_core/db_setup/utils.js

@@ -0,0 +1,30 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { pathExists } from 'path-exists';
+export const readMigrationEntries = async (buildDir, migrationsSrc) => {
+    const empty = { dirNames: [], fileNames: [] };
+    if (!migrationsSrc) {
+        return empty;
+    }
+    const srcDir = resolve(buildDir, migrationsSrc);
+    if (!(await pathExists(srcDir))) {
+        return empty;
+    }
+    const entries = await readdir(srcDir);
+    const dirNames = [];
+    const fileNames = [];
+    for (const entry of entries) {
+        const entryStat = await stat(join(srcDir, entry));
+        if (entryStat.isDirectory()) {
+            dirNames.push(entry);
+        }
+        else if (entry.endsWith('.sql')) {
+            fileNames.push(entry);
+        }
+    }
+    return { dirNames, fileNames };
+};
+export const getMigrationNames = ({ dirNames, fileNames }) => [
+    ...dirNames,
+    ...fileNames.map((f) => f.replace(/\.sql$/, '')),
+];

package/lib/plugins_core/db_setup/validation.d.ts

@@ -1,16 +1,18 @@
 export declare const MIGRATION_DIR_PATTERN: RegExp;
+export declare const MIGRATION_FILE_PATTERN: RegExp;
 interface ValidationError {
-    type: 'invalid_dir_name' | 'missing_sql_file';
+    type: 'missing_sql_file';
     dirName: string;
 }
 interface ValidationResult {
     valid: true;
     dirs: string[];
+    files: string[];
 }
 interface ValidationFailure {
     valid: false;
     errors: ValidationError[];
 }
-export declare const validateMigrationDirs: (dirNames: string[], existingSqlFiles: Set<string>) => ValidationResult | ValidationFailure;
+export declare const validateMigrations: (dirNames: string[], fileNames: string[], existingSqlFiles: Set<string>) => ValidationResult | ValidationFailure;
 export declare const formatValidationErrors: (errors: ValidationError[]) => string;
 export {};

package/lib/plugins_core/db_setup/validation.js

@@ -1,11 +1,13 @@
-export const MIGRATION_DIR_PATTERN = /^\d+_[a-z0-9-]+$/;
-export const validateMigrationDirs = (dirNames, existingSqlFiles) => {
+export const MIGRATION_DIR_PATTERN = /^\d+_[a-z0-9_-]+$/;
+export const MIGRATION_FILE_PATTERN = /^\d+_[a-z0-9_-]+\.sql$/;
+export const validateMigrations = (dirNames, fileNames, existingSqlFiles) => {
     const errors = [];
+    const matchingDirs = [];
     for (const dirName of dirNames) {
         if (!MIGRATION_DIR_PATTERN.test(dirName)) {
-            errors.push({ type: 'invalid_dir_name', dirName });
             continue;
         }
+        matchingDirs.push(dirName);
         if (!existingSqlFiles.has(dirName)) {
             errors.push({ type: 'missing_sql_file', dirName });
         }
@@ -13,19 +15,21 @@ export const validateMigrationDirs = (dirNames, existingSqlFiles) => {
     if (errors.length > 0) {
         return { valid: false, errors };
     }
-    const sorted = [...dirNames].sort();
-    return { valid: true, dirs: sorted };
+    const matchingFiles = [];
+    for (const fileName of fileNames) {
+        if (MIGRATION_FILE_PATTERN.test(fileName)) {
+            matchingFiles.push(fileName);
+        }
+    }
+    return {
+        valid: true,
+        dirs: [...matchingDirs].sort(),
+        files: [...matchingFiles].sort(),
+    };
 };
 export const formatValidationErrors = (errors) => {
     const lines = errors.map((error) => {
-        if (error.type === 'invalid_dir_name') {
-            return `  - "${error.dirName}" does not match the required pattern "<number>_<slug>" (e.g. "1700000000_create-users" or "001_create-users"). Slugs must be lowercase alphanumeric with hyphens.`;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (error.type === 'missing_sql_file') {
-            return `  - "${error.dirName}/migration.sql" is missing.`;
-        }
-        return `  - "${error.dirName}": unknown validation error.`;
+        return `  - "${error.dirName}/migration.sql" is missing.`;
     });
     return `Database migration validation failed:\n${lines.join('\n')}`;
 };

package/lib/plugins_core/db_setup/validation.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { MIGRATION_DIR_PATTERN, validateMigrationDirs, formatValidationErrors } from './validation.js';
+import { MIGRATION_DIR_PATTERN, MIGRATION_FILE_PATTERN, validateMigrations, formatValidationErrors, } from './validation.js';
 describe('MIGRATION_DIR_PATTERN', () => {
     const validNames = [
         '1700000000_create-users',
@@ -12,13 +12,15 @@ describe('MIGRATION_DIR_PATTERN', () => {
         '1_init',
         '0001_add-posts',
         '42_z',
+        '1700000000_under_score',
+        '001_create_users_table',
+        '1_a_b_c',
     ];
     test.each(validNames)('matches valid name: %s', (name) => {
         expect(MIGRATION_DIR_PATTERN.test(name)).toBe(true);
     });
     const invalidNames = [
         { name: '1700000000_CAPS', reason: 'uppercase letters' },
-        { name: '1700000000_under_score', reason: 'underscores in slug' },
         { name: 'no-timestamp', reason: 'no numeric prefix' },
         { name: '1700000000_', reason: 'empty slug' },
         { name: '1700000000', reason: 'missing underscore and slug' },
@@ -30,60 +32,108 @@ describe('MIGRATION_DIR_PATTERN', () => {
         expect(MIGRATION_DIR_PATTERN.test(name)).toBe(false);
     });
 });
-describe('validateMigrationDirs', () => {
+describe('MIGRATION_FILE_PATTERN', () => {
+    const validNames = [
+        '1700000000_create-users.sql',
+        '001_create_users_table.sql',
+        '1_init.sql',
+        '42_a-b-c.sql',
+        '1700000000_under_score.sql',
+    ];
+    test.each(validNames)('matches valid name: %s', (name) => {
+        expect(MIGRATION_FILE_PATTERN.test(name)).toBe(true);
+    });
+    const invalidNames = [
+        { name: '1700000000_CAPS.sql', reason: 'uppercase letters' },
+        { name: 'no-timestamp.sql', reason: 'no numeric prefix' },
+        { name: '1700000000_.sql', reason: 'empty slug' },
+        { name: '1700000000_create-users.txt', reason: 'wrong extension' },
+        { name: '1700000000_create-users', reason: 'no extension' },
+        { name: '1700000000_hello world.sql', reason: 'spaces in slug' },
+    ];
+    test.each(invalidNames)('rejects invalid name: $name ($reason)', ({ name }) => {
+        expect(MIGRATION_FILE_PATTERN.test(name)).toBe(false);
+    });
+});
+describe('validateMigrations', () => {
     test('returns valid result with sorted dirs when all dirs are valid', () => {
         const dirNames = ['1700000001_add-posts', '1700000000_create-users'];
         const existingSqlFiles = new Set(['1700000000_create-users', '1700000001_add-posts']);
-        const result = validateMigrationDirs(dirNames, existingSqlFiles);
-        expect(result.valid).toBe(true);
-        if (result.valid) {
-            expect(result.dirs).toEqual(['1700000000_create-users', '1700000001_add-posts']);
-        }
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: true,
+            dirs: ['1700000000_create-users', '1700000001_add-posts'],
+            files: [],
+        });
     });
-    test('returns error for invalid directory names', () => {
+    test('silently skips non-matching directory names', () => {
         const dirNames = ['bad-name', '1700000000_create-users'];
         const existingSqlFiles = new Set(['1700000000_create-users']);
-        const result = validateMigrationDirs(dirNames, existingSqlFiles);
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.errors).toEqual([{ type: 'invalid_dir_name', dirName: 'bad-name' }]);
-        }
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: true,
+            dirs: ['1700000000_create-users'],
+            files: [],
+        });
     });
     test('returns error for missing migration.sql files', () => {
         const dirNames = ['1700000000_create-users', '1700000001_add-posts'];
         const existingSqlFiles = new Set(['1700000000_create-users']);
-        const result = validateMigrationDirs(dirNames, existingSqlFiles);
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.errors).toEqual([{ type: 'missing_sql_file', dirName: '1700000001_add-posts' }]);
-        }
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: false,
+            errors: [{ type: 'missing_sql_file', dirName: '1700000001_add-posts' }],
+        });
+    });
+    test('returns valid result with sorted files for loose .sql files', () => {
+        const fileNames = ['002_add-posts.sql', '001_create-users.sql'];
+        const result = validateMigrations([], fileNames, new Set());
+        expect(result).toEqual({
+            valid: true,
+            dirs: [],
+            files: ['001_create-users.sql', '002_add-posts.sql'],
+        });
     });
-    test('reports both invalid names and missing files', () => {
-        const dirNames = ['bad-name', '1700000001_add-posts'];
-        const existingSqlFiles = new Set();
-        const result = validateMigrationDirs(dirNames, existingSqlFiles);
-        expect(result.valid).toBe(false);
-        if (!result.valid) {
-            expect(result.errors).toHaveLength(2);
-            expect(result.errors[0]).toEqual({ type: 'invalid_dir_name', dirName: 'bad-name' });
-            expect(result.errors[1]).toEqual({ type: 'missing_sql_file', dirName: '1700000001_add-posts' });
-        }
+    test('silently skips non-matching file names', () => {
+        const fileNames = ['README.sql', '001_create-users.sql', 'bad-name.sql'];
+        const result = validateMigrations([], fileNames, new Set());
+        expect(result).toEqual({
+            valid: true,
+            dirs: [],
+            files: ['001_create-users.sql'],
+        });
+    });
+    test('handles mixed dirs and files', () => {
+        const dirNames = ['1700000000_create-users'];
+        const fileNames = ['1700000001_add-posts.sql'];
+        const existingSqlFiles = new Set(['1700000000_create-users']);
+        const result = validateMigrations(dirNames, fileNames, existingSqlFiles);
+        expect(result).toEqual({
+            valid: true,
+            dirs: ['1700000000_create-users'],
+            files: ['1700000001_add-posts.sql'],
+        });
     });
     test('returns valid result for empty input', () => {
-        const result = validateMigrationDirs([], new Set());
-        expect(result.valid).toBe(true);
-        if (result.valid) {
-            expect(result.dirs).toEqual([]);
-        }
+        const result = validateMigrations([], [], new Set());
+        expect(result).toEqual({
+            valid: true,
+            dirs: [],
+            files: [],
+        });
+    });
+    test('allows underscores in dir names', () => {
+        const dirNames = ['001_create_users_table'];
+        const existingSqlFiles = new Set(['001_create_users_table']);
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: true,
+            dirs: ['001_create_users_table'],
+            files: [],
+        });
     });
 });
 describe('formatValidationErrors', () => {
-    test('formats invalid_dir_name errors', () => {
-        const message = formatValidationErrors([{ type: 'invalid_dir_name', dirName: 'bad-name' }]);
-        expect(message).toContain('Database migration validation failed');
-        expect(message).toContain('"bad-name"');
-        expect(message).toContain('<number>_<slug>');
-    });
     test('formats missing_sql_file errors', () => {
         const message = formatValidationErrors([{ type: 'missing_sql_file', dirName: '1700000000_create-users' }]);
         expect(message).toContain('Database migration validation failed');
@@ -91,10 +141,10 @@ describe('formatValidationErrors', () => {
     });
     test('formats multiple errors', () => {
         const message = formatValidationErrors([
-            { type: 'invalid_dir_name', dirName: 'bad-name' },
+            { type: 'missing_sql_file', dirName: '1700000000_create-users' },
             { type: 'missing_sql_file', dirName: '1700000001_add-posts' },
         ]);
-        expect(message).toContain('"bad-name"');
+        expect(message).toContain('"1700000000_create-users/migration.sql" is missing');
         expect(message).toContain('"1700000001_add-posts/migration.sql" is missing');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.10.0",
+  "version": "35.11.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -69,14 +69,14 @@
     "@bugsnag/js": "^8.0.0",
     "@netlify/blobs": "^10.4.4",
     "@netlify/cache-utils": "^6.0.5",
-    "@netlify/config": "^24.4.3",
-    "@netlify/edge-bundler": "14.9.17",
-    "@netlify/functions-utils": "^6.2.26",
+    "@netlify/config": "^24.4.4",
+    "@netlify/edge-bundler": "14.9.19",
+    "@netlify/functions-utils": "^6.2.27",
     "@netlify/git-utils": "^6.0.4",
     "@netlify/opentelemetry-utils": "^2.0.2",
     "@netlify/plugins-list": "^6.81.3",
     "@netlify/run-utils": "^6.0.3",
-    "@netlify/zip-it-and-ship-it": "14.5.0",
+    "@netlify/zip-it-and-ship-it": "14.5.1",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^7.0.0",
     "ansis": "^4.1.0",
@@ -152,5 +152,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "4c1f6b11490fca02a044a8f0e3bed51ef6b7c85a"
+  "gitHead": "3694352be4959c56e96a6c15dd04ed4d7aa31344"
 }