@netlify/build 35.11.1 → 35.12.0

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

@@ -1,9 +1,15 @@
 export declare const MIGRATION_DIR_PATTERN: RegExp;
 export declare const MIGRATION_FILE_PATTERN: RegExp;
-interface ValidationError {
+interface MissingSqlFileError {
     type: 'missing_sql_file';
     dirName: string;
 }
+interface DuplicateMigrationNumberError {
+    type: 'duplicate_migration_number';
+    migrationNumber: string;
+    names: string[];
+}
+type ValidationError = MissingSqlFileError | DuplicateMigrationNumberError;
 interface ValidationResult {
     valid: true;
     dirs: string[];
@@ -13,6 +19,7 @@ interface ValidationFailure {
     valid: false;
     errors: ValidationError[];
 }
+export declare const trackMigrationNumber: (numberToNames: Map<string, string[]>, name: string) => void;
 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,35 +1,56 @@
 export const MIGRATION_DIR_PATTERN = /^\d+_[a-z0-9_-]+$/;
 export const MIGRATION_FILE_PATTERN = /^\d+_[a-z0-9_-]+\.sql$/;
+export const trackMigrationNumber = (numberToNames, name) => {
+    const key = /^(\d+)_/.exec(name)[1].replace(/^0+/, '') || '0';
+    const existing = numberToNames.get(key);
+    if (existing) {
+        existing.push(name);
+    }
+    else {
+        numberToNames.set(key, [name]);
+    }
+};
 export const validateMigrations = (dirNames, fileNames, existingSqlFiles) => {
     const errors = [];
     const matchingDirs = [];
+    const numberToNames = new Map();
     for (const dirName of dirNames) {
         if (!MIGRATION_DIR_PATTERN.test(dirName)) {
             continue;
         }
         matchingDirs.push(dirName);
+        trackMigrationNumber(numberToNames, dirName);
         if (!existingSqlFiles.has(dirName)) {
             errors.push({ type: 'missing_sql_file', dirName });
         }
     }
-    if (errors.length > 0) {
-        return { valid: false, errors };
-    }
     const matchingFiles = [];
     for (const fileName of fileNames) {
         if (MIGRATION_FILE_PATTERN.test(fileName)) {
             matchingFiles.push(fileName);
+            trackMigrationNumber(numberToNames, fileName);
         }
     }
+    for (const [migrationNumber, names] of numberToNames) {
+        if (names.length > 1) {
+            errors.push({ type: 'duplicate_migration_number', migrationNumber, names: names.sort() });
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
     return {
         valid: true,
-        dirs: [...matchingDirs].sort(),
-        files: [...matchingFiles].sort(),
+        dirs: matchingDirs.sort(),
+        files: matchingFiles.sort(),
     };
 };
 export const formatValidationErrors = (errors) => {
     const lines = errors.map((error) => {
-        return `  - "${error.dirName}/migration.sql" is missing.`;
+        if (error.type === 'missing_sql_file') {
+            return `  - "${error.dirName}/migration.sql" is missing.`;
+        }
+        return `  - Duplicate migration number ${error.migrationNumber}: ${error.names.map((n) => `"${n}"`).join(', ')}`;
     });
     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, MIGRATION_FILE_PATTERN, validateMigrations, formatValidationErrors, } from './validation.js';
+import { MIGRATION_DIR_PATTERN, MIGRATION_FILE_PATTERN, trackMigrationNumber, validateMigrations, formatValidationErrors, } from './validation.js';
 describe('MIGRATION_DIR_PATTERN', () => {
     const validNames = [
         '1700000000_create-users',
@@ -55,6 +55,29 @@ describe('MIGRATION_FILE_PATTERN', () => {
         expect(MIGRATION_FILE_PATTERN.test(name)).toBe(false);
     });
 });
+describe('trackMigrationNumber', () => {
+    const cases = [
+        { name: '001_create-users', expected: '1' },
+        { name: '1_init', expected: '1' },
+        { name: '0001_add-posts', expected: '1' },
+        { name: '42_z', expected: '42' },
+        { name: '1700000000_create-users', expected: '1700000000' },
+        { name: '1700000000_create-users.sql', expected: '1700000000' },
+        { name: '001_create-users.sql', expected: '1' },
+        { name: '0000000000_init', expected: '0' },
+    ];
+    test.each(cases)('tracks $name under key $expected', ({ name, expected }) => {
+        const map = new Map();
+        trackMigrationNumber(map, name);
+        expect(map.get(expected)).toEqual([name]);
+    });
+    test('groups names with the same migration number', () => {
+        const map = new Map();
+        trackMigrationNumber(map, '001_create-users');
+        trackMigrationNumber(map, '1_init');
+        expect(map.get('1')).toEqual(['001_create-users', '1_init']);
+    });
+});
 describe('validateMigrations', () => {
     test('returns valid result with sorted dirs when all dirs are valid', () => {
         const dirNames = ['1700000001_add-posts', '1700000000_create-users'];
@@ -132,6 +155,52 @@ describe('validateMigrations', () => {
             files: [],
         });
     });
+    test('returns error for duplicate migration numbers in dirs', () => {
+        const dirNames = ['001_create-users', '001_add-posts'];
+        const existingSqlFiles = new Set(['001_create-users', '001_add-posts']);
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: false,
+            errors: [
+                { type: 'duplicate_migration_number', migrationNumber: '1', names: ['001_add-posts', '001_create-users'] },
+            ],
+        });
+    });
+    test('returns error for duplicate migration numbers in files', () => {
+        const fileNames = ['001_create-users.sql', '001_add-posts.sql'];
+        const result = validateMigrations([], fileNames, new Set());
+        expect(result).toEqual({
+            valid: false,
+            errors: [
+                {
+                    type: 'duplicate_migration_number',
+                    migrationNumber: '1',
+                    names: ['001_add-posts.sql', '001_create-users.sql'],
+                },
+            ],
+        });
+    });
+    test('returns error for duplicate migration numbers across dirs and files', () => {
+        const dirNames = ['001_create-users'];
+        const fileNames = ['001_add-posts.sql'];
+        const existingSqlFiles = new Set(['001_create-users']);
+        const result = validateMigrations(dirNames, fileNames, existingSqlFiles);
+        expect(result).toEqual({
+            valid: false,
+            errors: [
+                { type: 'duplicate_migration_number', migrationNumber: '1', names: ['001_add-posts.sql', '001_create-users'] },
+            ],
+        });
+    });
+    test('treats different zero-padded prefixes as duplicates', () => {
+        const dirNames = ['1_init', '001_setup'];
+        const existingSqlFiles = new Set(['1_init', '001_setup']);
+        const result = validateMigrations(dirNames, [], existingSqlFiles);
+        expect(result).toEqual({
+            valid: false,
+            errors: [{ type: 'duplicate_migration_number', migrationNumber: '1', names: ['001_setup', '1_init'] }],
+        });
+    });
 });
 describe('formatValidationErrors', () => {
     test('formats missing_sql_file errors', () => {
@@ -147,4 +216,11 @@ describe('formatValidationErrors', () => {
         expect(message).toContain('"1700000000_create-users/migration.sql" is missing');
         expect(message).toContain('"1700000001_add-posts/migration.sql" is missing');
     });
+    test('formats duplicate_migration_number errors', () => {
+        const message = formatValidationErrors([
+            { type: 'duplicate_migration_number', migrationNumber: '1', names: ['001_add-posts', '001_create-users'] },
+        ]);
+        expect(message).toContain('Database migration validation failed');
+        expect(message).toContain('Duplicate migration number 1: "001_add-posts", "001_create-users"');
+    });
 });

package/lib/plugins_core/secrets_scanning/utils.js

@@ -1,6 +1,7 @@
 import { createReadStream, promises as fs, existsSync } from 'node:fs';
 import path from 'node:path';
 import { fdir } from 'fdir';
+import ignore from 'ignore';
 import { minimatch } from 'minimatch';
 import { LIKELY_SECRET_PREFIXES, SAFE_LISTED_VALUES } from './secret_prefixes.js';
 /**
@@ -170,21 +171,16 @@ export function findLikelySecrets({ text, omitValuesFromEnhancedScan = [], }) {
  */
 export async function getFilePathsToScan({ env, base }) {
     const omitPathsAlways = ['.git/', '.cache/'];
-    // node modules is dense and is only useful to scan if the repo itself commits these
-    // files. As a simple check to understand if the repo would commit these files, we expect
-    // that they would not ignore them from their git settings. So if gitignore includes
-    // node_modules anywhere we will omit looking in those folders - this will allow repos
-    // that do commit node_modules to still scan them.
-    let ignoreNodeModules = false;
+    // Files/folders ignored by the repo's .gitignore should not be scanned, since they
+    // are not committed to the repo and are not part of the build output the user controls.
+    // This also naturally excludes things like node_modules when the repo gitignores it.
     const gitignorePath = path.resolve(base, '.gitignore');
     const gitignoreContents = existsSync(gitignorePath) ? await fs.readFile(gitignorePath, 'utf-8') : '';
-    if (gitignoreContents?.includes('node_modules')) {
-        ignoreNodeModules = true;
-    }
+    const gitIgnoreFilter = gitignoreContents ? ignore().add(gitignoreContents) : null;
     let files = await new fdir()
         .withRelativePaths()
-        .filter((path) => {
-        if (ignoreNodeModules && path.includes('node_modules')) {
+        .filter((filePath) => {
+        if (gitIgnoreFilter && filePath && gitIgnoreFilter.ignores(filePath)) {
             return false;
         }
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.11.1",
+  "version": "35.12.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -71,12 +71,12 @@
     "@netlify/cache-utils": "^6.0.5",
     "@netlify/config": "^24.4.4",
     "@netlify/edge-bundler": "14.9.19",
-    "@netlify/functions-utils": "^6.2.28",
+    "@netlify/functions-utils": "^6.2.29",
     "@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.2",
+    "@netlify/zip-it-and-ship-it": "14.5.3",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^7.0.0",
     "ansis": "^4.1.0",
@@ -86,6 +86,7 @@
     "figures": "^6.0.0",
     "filter-obj": "^6.0.0",
     "hot-shots": "11.4.0",
+    "ignore": "^7.0.0",
     "indent-string": "^5.0.0",
     "is-plain-obj": "^4.0.0",
     "keep-func-props": "^6.0.0",
@@ -152,5 +153,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "3a8928c89ea24449e8462bcc7e7065a07fc691e4"
+  "gitHead": "85ec413dbce5342df01289953b91169c1f84c34b"
 }