chore: leverage expressionFromString more in drizzle adder

packages/addons/_tests/drizzle/test.ts

@@ -43,7 +43,7 @@ test.concurrent.for(testCases)(
 
 		const ts = variant === 'kit-ts';
 		const drizzleConfig = path.resolve(cwd, `drizzle.config.${ts ? 'ts' : 'js'}`);
-		const content = fs.readFileSync(drizzleConfig, 'utf8').replace('strict: true,', '');
+		const content = fs.readFileSync(drizzleConfig, 'utf8').replace(/strict: true[,\s]/, '');
 		fs.writeFileSync(drizzleConfig, content, 'utf8');
 
 		const routes = path.resolve(cwd, 'src', 'routes');

packages/addons/drizzle/index.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { common, exports, functions, imports, object, variables } from '@sveltejs/cli-core/js';
 import { defineAddon, defineAddonOptions, dedent, type OptionValues } from '@sveltejs/cli-core';
 import { parseJson, parseScript } from '@sveltejs/cli-core/parsers';
@@ -69,8 +71,21 @@ export default defineAddon({
 	shortDescription: 'database orm',
 	homepage: 'https://orm.drizzle.team',
 	options,
-	setup: ({ kit, unsupported }) => {
+	setup: ({ kit, unsupported, cwd, typescript }) => {
+		const ext = typescript ? 'ts' : 'js';
 		if (!kit) unsupported('Requires SvelteKit');
+
+		const baseDBPath = path.resolve(kit!.libDirectory, 'server', 'db');
+		const paths = {
+			'drizzle config': path.relative(cwd, path.resolve(cwd, `drizzle.config.${ext}`)),
+			'database schema': path.relative(cwd, path.resolve(baseDBPath, `schema.${ext}`)),
+			database: path.relative(cwd, path.resolve(baseDBPath, `index.${ext}`))
+		};
+		for (const [fileType, filePath] of Object.entries(paths)) {
+			if (fs.existsSync(filePath)) {
+				unsupported(`Preexisting ${fileType} file at '${filePath}'`);
+			}
+		}
 	},
 	run: ({ sv, typescript, options, kit }) => {
 		const ext = typescript ? 'ts' : 'js';
@@ -178,41 +193,27 @@ export default defineAddon({
 
 			imports.addNamed(ast, 'drizzle-kit', { defineConfig: 'defineConfig' });
 
-			const envCheckStatement = common.statementFromString(
-				"if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
+			common.addStatement(
+				ast,
+				common.statementFromString(
+					"if (!process.env.DATABASE_URL) throw new Error('DATABASE_URL is not set');"
+				)
 			);
-			common.addStatement(ast, envCheckStatement);
-
-			const fallback = common.expressionFromString('defineConfig({})');
-			const { value: exportDefault } = exports.defaultExport(ast, fallback);
-			if (exportDefault.type !== 'CallExpression') return content;
-
-			const objExpression = exportDefault.arguments?.[0];
-			if (!objExpression || objExpression.type !== 'ObjectExpression') return content;
-
-			const authToken =
-				options.sqlite === 'turso'
-					? common.expressionFromString('process.env.DATABASE_AUTH_TOKEN')
-					: undefined;
-
-			object.properties(objExpression, {
-				schema: common.createLiteral(`./src/lib/server/db/schema.${typescript ? 'ts' : 'js'}`),
-				dbCredentials: object.create({
-					url: common.expressionFromString('process.env.DATABASE_URL'),
-					authToken
-				}),
-				verbose: { type: 'Literal', value: true },
-				strict: { type: 'Literal', value: true }
-			});
-
-			const dialect = options.sqlite === 'turso' ? 'turso' : options.database;
-			object.overrideProperties(objExpression, {
-				dialect: common.createLiteral(dialect)
-			});
 
-			// The `driver` property is only required for _some_ sqlite DBs.
-			// We'll need to remove it if it's anything but sqlite
-			if (options.database !== 'sqlite') object.removeProperty(objExpression, 'driver');
+			exports.defaultExport(
+				ast,
+				common.expressionFromString(`
+					defineConfig({
+						schema: "./src/lib/server/db/schema.${typescript ? 'ts' : 'js'}",
+						dialect: "${options.sqlite === 'turso' ? 'turso' : options.database}",
+						dbCredentials: {
+							${options.sqlite === 'turso' ? 'authToken: process.env.DATABASE_AUTH_TOKEN,' : ''}
+							url: process.env.DATABASE_URL
+						},
+						verbose: true,
+						strict: true
+					})`)
+			);
 
 			return generateCode();
 		});

packages/core/tests/js/common/expression-from-string/output.ts

@@ -0,0 +1 @@
+export default defineConfig({ path: 'some/string/as/path.js', valid: true });

packages/core/tests/js/common/expression-from-string/run.ts

@@ -0,0 +1,13 @@
+import { common, exports, type AstTypes } from '@sveltejs/cli-core/js';
+
+export function run(ast: AstTypes.Program): void {
+	exports.defaultExport(
+		ast,
+		common.expressionFromString(`
+			defineConfig({
+				path: "some/string/as/path.js",
+				valid: true
+			})
+		`)
+	);
+}

packages/core/tests/js/index.ts

@@ -1,17 +1,12 @@
 import fs from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import prettier from 'prettier';
 import { describe, expect, test } from 'vitest';
 import { parseScript, serializeScript } from '../../tooling/index.ts';
 
 const baseDir = resolve(fileURLToPath(import.meta.url), '..');
 const categoryDirectories = getDirectoryNames(baseDir);
 
-const prettierConfig = await prettier.resolveConfig(import.meta.url);
-if (!prettierConfig) throw new Error('Failed to resolve prettier config');
-prettierConfig.filepath = 'output.ts';
-
 for (const categoryDirectory of categoryDirectories) {
 	describe(categoryDirectory, () => {
 		const testNames = getDirectoryNames(join(baseDir, categoryDirectory));
@@ -27,9 +22,9 @@ for (const categoryDirectory of categoryDirectories) {
 				const module = await import(`./${categoryDirectory}/${testName}/run.ts`);
 				module.run(ast);
 
-				const output = serializeScript(ast, input);
-				const formattedOutput = await prettier.format(output, prettierConfig);
-				await expect(formattedOutput).toMatchFileSnapshot(`${testDirectoryPath}/output.ts`);
+				let output = serializeScript(ast, input);
+				if (!output.endsWith('\n')) output += '\n';
+				await expect(output).toMatchFileSnapshot(`${testDirectoryPath}/output.ts`);
 			});
 		}
 	});

packages/core/tooling/js/common.ts

@@ -115,6 +115,7 @@ export function addFromString(
 
 export function expressionFromString(value: string): AstTypes.Expression {
 	const program = parseScript(dedent(value));
+	stripAst(program, ['raw']);
 	const statement = program.body[0]!;
 	if (statement.type !== 'ExpressionStatement') {
 		throw new Error('value passed was not an expression');