Merge pull request #11 from replit/bb-array-defaults

Fix parsing of array defaults

Author: brenoafb

drizzle-kit/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drizzle-team/drizzle-kit",
-	"version": "0.31.10",
+	"version": "0.31.11",
 	"homepage": "https://orm.drizzle.team",
 	"keywords": [
 		"drizzle",
@@ -47,7 +47,8 @@
 		"@drizzle-team/brocli": "^0.10.2",
 		"@esbuild-kit/esm-loader": "^2.5.5",
 		"esbuild": "^0.25.4",
-		"esbuild-register": "^3.5.0"
+		"esbuild-register": "^3.5.0",
+		"postgres-array": "^3.0.4"
 	},
 	"devDependencies": {
 		"@arethetypeswrong/cli": "^0.15.3",

drizzle-kit/src/serializer/pgSerializer.ts

@@ -40,6 +40,7 @@ import type {
 	UniqueConstraint,
 	View,
 } from '../serializer/pgSchema';
+import { parse as parsePostgresArray } from 'postgres-array';
 import { type DB, escapeSingleQuotes, isPgArrayType } from '../utils';
 import { getColumnCasing, sqlToStr } from './utils';
 
@@ -1934,7 +1935,91 @@ WHERE
 	};
 };
 
-const defaultForColumn = (column: any, internals: PgKitInternals, tableName: string) => {
+/**
+ * Formats a single array element based on the PostgreSQL column data type.
+ * Handles cleaning up quotes and spaces from postgres-array parsed elements,
+ * and applies appropriate formatting for different data types.
+ */
+const formatArrayElement = (element: any, dataType: string): string | null => {
+	if (element === null) return element;
+	
+	// Remove outer quotes from postgres-array parsed elements if present
+	// First trim spaces since postgres-array includes leading spaces in array elements
+	let cleanElement = typeof element === 'string' ? element.trim() : element;
+	if (typeof cleanElement === 'string' && ((cleanElement.startsWith("'") && cleanElement.endsWith("'")) || (cleanElement.startsWith('"') && cleanElement.endsWith('"')))) {
+		cleanElement = cleanElement.slice(1, -1);
+	}
+
+	// remove [] from dataType if it exists
+	if (!dataType.endsWith("[]")) {
+		throw new Error(`array dataType ${dataType} does not end with '[]'`);
+	}
+
+	const baseDataType = dataType.slice(0, -"[]".length);
+	
+	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(baseDataType)) {
+		return cleanElement;
+	} else if (dataType.startsWith('timestamp')) {
+		return `"${cleanElement}"`;
+	} else if (baseDataType === 'interval') {
+		return `"${cleanElement.replaceAll('"', `\"`)}"`;
+	} else if (baseDataType === 'boolean') {
+		return cleanElement === 't' || cleanElement === 'true' ? 'true' : 'false';
+	} else if (['json', 'jsonb'].includes(baseDataType)) {
+		// For JSON/JSONB arrays, cleanElement is already a JSON string
+		// We just need to ensure it's properly quoted
+		
+		// First, try to parse it to validate it's valid JSON
+		const parsed = JSON.parse(cleanElement);
+		// Then stringify it back to ensure consistent formatting
+		return `"${JSON.stringify(parsed).replaceAll('"', '\\"')}"`;
+	} else {
+		return `"${cleanElement}"`;
+	}
+};
+
+/**
+ * Handles the default value formatting for array columns.
+ * Converts various array formats to PostgreSQL array notation and formats elements.
+ */
+const handleArrayDefault = (columnDefaultAsString: string, dataType: string): string => {
+	// Handle common simple cases
+	if (columnDefaultAsString === '{}' || columnDefaultAsString === "'{}'") {
+		return "'{}'";
+	} else if (columnDefaultAsString === '{""}' || columnDefaultAsString === "'{\"\"}'") {
+		return "'{\"\"}'";
+	}
+
+	// Convert ARRAY constructor syntax to PostgreSQL bracket notation that postgres-array can parse
+	let normalizedArrayString = columnDefaultAsString;
+	
+	if (columnDefaultAsString.startsWith('ARRAY[') && columnDefaultAsString.endsWith(']')) {
+		// Convert ARRAY['a'::text, 'b', 'c'::varchar] -> {'a', 'b', 'c'}
+		const content = columnDefaultAsString.slice(6, -1); // Remove 'ARRAY[' and ']'
+		
+		// Remove type casting from individual elements (::text, ::varchar, etc.)
+		const cleanContent = content.replace(/::\w+/g, '');
+		normalizedArrayString = `{${cleanContent}}`;
+	}
+	
+	// Handle various bracket notation formats to ensure compatibility with postgres-array
+	if (normalizedArrayString.startsWith("'{") && normalizedArrayString.endsWith("}'")) {
+		normalizedArrayString = normalizedArrayString.slice(1, -1); // Remove outer quotes
+	} else if (!normalizedArrayString.startsWith("{") && !normalizedArrayString.startsWith("'") && normalizedArrayString !== '{}') {
+		// Handle cases where array string doesn't have proper brackets
+		normalizedArrayString = `{${normalizedArrayString}}`;
+	}
+
+	// Use postgres-array library to parse the normalized string
+	const parsedArray = [...parsePostgresArray(normalizedArrayString)];
+	
+	// Format elements according to data type
+	const formattedElements = parsedArray.map((element) => formatArrayElement(element, dataType));
+	
+	return `'{${formattedElements.join(',')}}'`;
+};
+
+export const defaultForColumn = (column: any, internals: PgKitInternals, tableName: string) => {
 	const columnName = column.column_name;
 	const isArray = internals?.tables[tableName]?.columns[columnName]?.isArray ?? false;
 
@@ -1961,27 +2046,7 @@ const defaultForColumn = (column: any, internals: PgKitInternals, tableName: str
 	const columnDefaultAsString: string = column.column_default.toString();
 
 	if (isArray) {
-		return `'{${
-			columnDefaultAsString
-				.slice(2, -2)
-				.split(/\s*,\s*/g)
-				.map((value) => {
-					if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(column.data_type.slice(0, -2))) {
-						return value;
-					} else if (column.data_type.startsWith('timestamp')) {
-						return `${value}`;
-					} else if (column.data_type.slice(0, -2) === 'interval') {
-						return value.replaceAll('"', `\"`);
-					} else if (column.data_type.slice(0, -2) === 'boolean') {
-						return value === 't' ? 'true' : 'false';
-					} else if (['json', 'jsonb'].includes(column.data_type.slice(0, -2))) {
-						return JSON.stringify(JSON.stringify(JSON.parse(JSON.parse(value)), null, 0));
-					} else {
-						return `\"${value}\"`;
-					}
-				})
-				.join(',')
-		}}'`;
+		return handleArrayDefault(columnDefaultAsString, column.data_type);
 	}
 
 	if (['integer', 'smallint', 'bigint', 'double precision', 'real'].includes(column.data_type)) {