AINATIVEM-44 OAuth callback, token repository, and pipedrive client generator

package.json

@@ -12,6 +12,7 @@
     "lint": "eslint src",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
+    "clean": "rm -rf apps/",
     "generate": "tsx src/cli.ts apps/test-app",
     "prepare": "husky"
   },

src/cli.ts

@@ -4,7 +4,6 @@ import { basename, resolve } from 'node:path';
 import { promptAppExtensions } from './prompts/appExtensions.js';
 import { promptDatabase } from './prompts/database.js';
 import { promptProjectName } from './prompts/projectName.js';
-import { promptWebhooks } from './prompts/webhooks.js';
 import { nodeGenerator } from './generators/node/index.js';
 
 async function main(): Promise<void> {
@@ -13,13 +12,12 @@ async function main(): Promise<void> {
 	const nameOrPath = await promptProjectName(process.argv[2]);
 	const database = await promptDatabase();
 	const appExtensions = await promptAppExtensions();
-	const webhooks = await promptWebhooks();
 
 	const outputDir = resolve(process.cwd(), nameOrPath);
 	const projectName = basename(outputDir);
 
 	try {
-		await nodeGenerator.generate(outputDir, { projectName, database, appExtensions, webhooks });
+		await nodeGenerator.generate(outputDir, { projectName, database, appExtensions });
 	} catch (error) {
 		clack.log.error(`Generation failed: ${error instanceof Error ? error.message : String(error)}`);
 		process.exit(1);
@@ -40,13 +38,12 @@ async function main(): Promise<void> {
 		spinner.stop(ok ? 'Dependencies installed' : 'npm install failed — run it manually');
 	}
 
-	const needsDocker = database === 'postgres' || database === 'mysql';
 	console.log('\nNext steps:');
 	console.log(`  cd ${nameOrPath}`);
 	console.log('  cp .env.example .env');
-	if (needsDocker) console.log('  docker-compose up -d');
+	console.log('  # fill in PIPEDRIVE_CLIENT_ID and PIPEDRIVE_CLIENT_SECRET');
 	if (!installDeps) console.log('  npm install');
-	console.log('  npm run dev');
+	console.log('  docker compose up');
 }
 
 main();

src/generators/interface.ts

@@ -4,7 +4,6 @@ export type AppExtensionType = 'custom-panel' | 'custom-modal';
 export interface GeneratorOptions {
 	projectName: string;
 	database: Database;
-	webhooks: boolean;
 	appExtensions: AppExtensionType[];
 }
 

src/generators/node/app.test.ts

@@ -21,40 +21,39 @@ describe('generateApp', () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: [],
 		});
 		expect(content).toContain("from 'express'");
 		expect(content).toContain("from './oauth/index.js'");
+		expect(content).toContain('createAuthRedirect');
 		expect(content).toContain("app.use('/oauth'");
 	});
 
-	it('includes webhooks import and mount when webhooks is true', async () => {
+	it('has root route that redirects to oauth when not installed', async () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: true,
 			appExtensions: [],
 		});
-		expect(content).toContain("from './webhooks/index.js'");
-		expect(content).toContain("app.use('/webhooks'");
+		expect(content).toContain("app.get('/'");
+		expect(content).toContain('createAuthRedirect()');
+		expect(content).toContain('client.deals.getDeals()');
 	});
 
-	it('excludes webhooks when webhooks is false', async () => {
+	it('has global error handler', async () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: [],
 		});
-		expect(content).not.toContain('./webhooks/index.js');
+		expect(content).toContain('NextFunction');
+		expect(content).toContain('res.status(500)');
 	});
 
 	it('includes panel import and mount when custom-panel is selected', async () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: ['custom-panel'],
 		});
 		expect(content).toContain("from './app-extensions/panel/index.js'");
@@ -65,7 +64,6 @@ describe('generateApp', () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: ['custom-modal'],
 		});
 		expect(content).toContain("from './app-extensions/modal/index.js'");
@@ -76,7 +74,6 @@ describe('generateApp', () => {
 		const content = await getAppContent({
 			projectName: 'test-app',
 			database: 'sqlite',
-			webhooks: false,
 			appExtensions: [],
 		});
 		expect(content).not.toContain('./app-extensions');

src/generators/node/app.ts

@@ -1,3 +1,4 @@
+import dedent from 'dedent';
 import { join } from 'path';
 import { writeFile } from '../../utils/writeFile.js';
 import type { GeneratorOptions } from '../interface.js';
@@ -10,19 +11,49 @@ export async function generateApp(outputDir: string, options: GeneratorOptions):
 
 	const mounts = new RouterMountBuilder()
 		.add('/oauth', 'oauthRouter')
-		.addIf(options.webhooks, '/webhooks', 'webhooksRouter')
 		.addIf(hasPanel, '/extensions/panel', 'panelRouter')
 		.addIf(hasModal, '/extensions/modal', 'modalRouter')
 		.build();
 
+	const rootRoute = dedent`
+		app.get('/', async (_req, res, next) => {
+			try {
+				const rows = await db.select().from(pipedriveTokens).orderBy(desc(pipedriveTokens.updatedAt)).limit(1);
+				if (!rows[0]) {
+					res.redirect(createAuthRedirect());
+					return;
+				}
+				const client = await getClient(rows[0].pipedriveCompanyId);
+				const deals = await client.deals.getDeals();
+				res.json(deals);
+			} catch (err) {
+				next(err);
+			}
+		});
+	`;
+
+	const errorHandler = dedent`
+		app.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
+			console.error(err);
+			res.status(500).send(err.message);
+		});
+	`;
+
 	const content = new SourceFileBuilder()
 		.importDefault('express', 'express')
+		.import('express', ['NextFunction', 'Request', 'Response'])
 		.importDefault('./oauth/index.js', 'oauthRouter')
-		.importDefaultIf(options.webhooks, './webhooks/index.js', 'webhooksRouter')
+		.import('./oauth/index.js', ['createAuthRedirect'])
+		.import('./pipedrive/client.js', ['getClient'])
+		.import('./database/index.js', ['db'])
+		.import('./database/schema.js', ['pipedriveTokens'])
+		.import('drizzle-orm', ['desc'])
 		.importDefaultIf(hasPanel, './app-extensions/panel/index.js', 'panelRouter')
 		.importDefaultIf(hasModal, './app-extensions/modal/index.js', 'modalRouter')
 		.addBlock('const app = express();')
+		.addBlock(rootRoute)
 		.addBlock(mounts)
+		.addBlock(errorHandler)
 		.exportDefault('app')
 		.build();
 

src/generators/node/appExtensions.test.ts

@@ -21,7 +21,6 @@ describe('generateAppExtensions', () => {
 		const options: GeneratorOptions = {
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: ['custom-panel'],
 		};
 		await generateAppExtensions(tmpDir, options);
@@ -34,7 +33,6 @@ describe('generateAppExtensions', () => {
 		const options: GeneratorOptions = {
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: ['custom-modal'],
 		};
 		await generateAppExtensions(tmpDir, options);
@@ -47,7 +45,6 @@ describe('generateAppExtensions', () => {
 		const options: GeneratorOptions = {
 			projectName: 'test-app',
 			database: 'postgres',
-			webhooks: false,
 			appExtensions: ['custom-panel', 'custom-modal'],
 		};
 		await generateAppExtensions(tmpDir, options);

src/generators/node/database.test.ts

@@ -19,21 +19,18 @@ afterEach(async () => {
 const pgOptions: GeneratorOptions = {
 	projectName: 'test-app',
 	database: 'postgres',
-	webhooks: false,
 	appExtensions: [],
 };
 
 const mysqlOptions: GeneratorOptions = {
 	projectName: 'test-app',
 	database: 'mysql',
-	webhooks: false,
 	appExtensions: [],
 };
 
 const sqliteOptions: GeneratorOptions = {
 	projectName: 'test-app',
 	database: 'sqlite',
-	webhooks: false,
 	appExtensions: [],
 };
 
@@ -216,32 +213,95 @@ describe('generateDatabase — drizzle.config.ts', () => {
 });
 
 describe('generateDatabase — docker-compose.yml', () => {
-	it('generates docker-compose.yml for postgres with healthcheck', async () => {
+	it('generates docker-compose.yml for postgres with backend and healthcheck', async () => {
 		const { generateDatabase } = await import('./database.js');
 		await generateDatabase(tmpDir, pgOptions);
 		expect(await exists(join(tmpDir, 'docker-compose.yml'))).toBe(true);
 		const content = await read('docker-compose.yml');
 		expect(content).toContain('postgres:16');
-		expect(content).toContain('postgres_data:/var/lib/postgresql/data');
+		expect(content).toContain('db_data:/var/lib/postgresql/data');
 		expect(content).toContain('pg_isready');
 		expect(content).toContain('healthcheck');
+		expect(content).toContain('backend');
+		expect(content).toContain('tsx watch src/index.ts');
+		expect(content).toContain('action: sync');
 	});
 
-	it('generates docker-compose.yml for mysql with healthcheck', async () => {
+	it('generates docker-compose.yml for mysql with backend and healthcheck', async () => {
 		const { generateDatabase } = await import('./database.js');
 		await generateDatabase(tmpDir, mysqlOptions);
 		const content = await read('docker-compose.yml');
 		expect(content).toContain('mysql:8');
 		expect(content).toContain('127.0.0.1:3307:3306');
 		expect(content).not.toContain('3306:3306');
-		expect(content).toContain('mysql_data:/var/lib/mysql');
+		expect(content).toContain('db_data:/var/lib/mysql');
 		expect(content).toContain('mysqladmin');
 		expect(content).toContain('healthcheck');
+		expect(content).toContain('backend');
+		expect(content).toContain('tsx watch src/index.ts');
 	});
 
-	it('does not generate docker-compose.yml for sqlite', async () => {
+	it('generates docker-compose.yml for sqlite with backend only', async () => {
 		const { generateDatabase } = await import('./database.js');
 		await generateDatabase(tmpDir, sqliteOptions);
-		expect(await exists(join(tmpDir, 'docker-compose.yml'))).toBe(false);
+		expect(await exists(join(tmpDir, 'docker-compose.yml'))).toBe(true);
+		const content = await read('docker-compose.yml');
+		expect(content).toContain('backend');
+		expect(content).toContain('tsx watch src/index.ts');
+		expect(content).toContain('sqlite_data');
+		expect(content).not.toContain('mysql');
+		expect(content).not.toContain('postgres');
+	});
+});
+
+describe('generateDatabase — tokenRepository.ts', () => {
+	it('generates src/database/tokenRepository.ts', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, pgOptions);
+		expect(await exists(join(tmpDir, 'src/database/tokenRepository.ts'))).toBe(true);
+	});
+
+	it('exports getToken, getTokenByCompany, upsertToken', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, pgOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain('export async function getToken');
+		expect(content).toContain('export async function getTokenByCompany');
+		expect(content).toContain('export async function upsertToken');
+	});
+
+	it('exports StoredToken type', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, pgOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain('StoredToken');
+	});
+
+	it('imports TokenResponse from pipedrive/v2', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, pgOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain("from 'pipedrive/v2'");
+	});
+
+	it('postgres uses onConflictDoUpdate', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, pgOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain('onConflictDoUpdate');
+	});
+
+	it('mysql uses onDuplicateKeyUpdate', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, mysqlOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain('onDuplicateKeyUpdate');
+	});
+
+	it('sqlite uses onConflictDoUpdate', async () => {
+		const { generateDatabase } = await import('./database.js');
+		await generateDatabase(tmpDir, sqliteOptions);
+		const content = await read('src/database/tokenRepository.ts');
+		expect(content).toContain('onConflictDoUpdate');
 	});
 });