@netlify/build 35.9.0 → 35.10.1

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { buildSite } from './core/main.js';
 export { NetlifyPluginConstants } from './core/constants.js';
+export { getVersion } from './utils/json.js';
 export type { LogOutput as Logs } from './log/logger.js';
 export type { GeneratedFunction } from './steps/return_values.js';
 export type { NetlifyPlugin } from './types/netlify_plugin.js';

package/lib/index.js

@@ -1,4 +1,5 @@
 import { buildSite } from './core/main.js';
+export { getVersion } from './utils/json.js';
 // actual main types
 export { startDev } from './core/dev.js';
 export { runCoreSteps } from './steps/run_core_steps.js';

package/lib/plugins_core/db_setup/migrations.js

@@ -1,7 +1,7 @@
 import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { pathExists } from 'path-exists';
-import { validateMigrationDirs, formatValidationErrors } from './validation.js';
+import { validateMigrations, formatValidationErrors } from './validation.js';
 const condition = async ({ featureFlags, constants, buildDir }) => {
     if (!featureFlags?.netlify_build_db_setup) {
         return false;
@@ -17,13 +17,17 @@ const coreStep = async ({ constants, buildDir, systemLog }) => {
     const destDir = resolve(buildDir, constants.DB_MIGRATIONS_DIST);
     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);
+        }
     }
-    if (dirNames.length === 0) {
+    if (dirNames.length === 0 && fileNames.length === 0) {
         systemLog('No migration directories found, skipping copy.');
         return {};
     }
@@ -34,7 +38,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 +48,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 = {

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/lib/utils/json.d.ts

@@ -5,3 +5,4 @@ export type RootPackageJson = {
 };
 export declare const importJsonFile: (filePath: string) => Promise<PackageJson>;
 export declare const ROOT_PACKAGE_JSON: RootPackageJson;
+export declare const getVersion: () => string;

package/lib/utils/json.js

@@ -8,3 +8,4 @@ export const importJsonFile = async function (filePath) {
     return JSON.parse(fileContents);
 };
 export const ROOT_PACKAGE_JSON = (await importJsonFile(ROOT_PACKAGE_JSON_PATH));
+export const getVersion = () => ROOT_PACKAGE_JSON.version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.9.0",
+  "version": "35.10.1",
   "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.16",
-    "@netlify/functions-utils": "^6.2.26",
+    "@netlify/config": "^24.4.4",
+    "@netlify/edge-bundler": "14.9.18",
+    "@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": "6588f01d80a48a02ecdf660eead20ae0d728e075"
+  "gitHead": "d215694819e87e39ff42e863ed05124f5fd3da98"
 }