@techstream/quark-create-app 1.5.3 → 1.7.0

package/templates/base-project/packages/db/scripts/seed.js

@@ -1,40 +1,127 @@
+import { faker } from "@faker-js/faker";
 import bcrypt from "bcryptjs";
-import { PrismaClient } from "../src/generated/prisma/client.js";
+import { prisma } from "../src/index.js";
 
-const prisma = new PrismaClient();
+// Deterministic output — change this integer to get a different but consistent dataset
+faker.seed(42);
 
-async function main() {
-	console.log("Seeding database...");
-
-	const email = "test@example.com";
-	const password = await bcrypt.hash("Password1", 12);
-
-	const user = await prisma.user.upsert({
-		where: { email },
-		update: {},
-		create: {
-			email,
-			name: "Test User",
-			password,
-			image: "https://api.dicebear.com/7.x/avataaars/svg?seed=test",
-			posts: {
-				create: [
-					{
-						title: "Hello World",
-						content: "This is a seeded post. Welcome to Quark!",
-						published: true,
-					},
-					{
-						title: "Draft Post",
-						content: "This is a draft post. It is not published yet.",
-						published: false,
-					},
-				],
+const PROFILE = process.env.SEED_PROFILE ?? "dev";
+const VALID_PROFILES = ["minimal", "dev"];
+
+if (!VALID_PROFILES.includes(PROFILE)) {
+	console.error(
+		`Unknown SEED_PROFILE "${PROFILE}". Valid options: ${VALID_PROFILES.join(", ")}`,
+	);
+	process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Seeders
+// ---------------------------------------------------------------------------
+
+async function seedUsers() {
+	const users = [
+		{
+			email: "admin@example.com",
+			name: "Admin User",
+			role: "admin",
+			password: "Password1",
+		},
+		{
+			email: "viewer@example.com",
+			name: "Viewer User",
+			role: "viewer",
+			password: "Password1",
+		},
+	];
+
+	const seeded = [];
+	for (const userData of users) {
+		// Skip hashing if the user already exists — upsert update:{} won't use it anyway.
+		const existing = await prisma.user.findUnique({
+			where: { email: userData.email },
+		});
+		const hashed =
+			existing?.password ?? (await bcrypt.hash(userData.password, 12));
+		const user = await prisma.user.upsert({
+			where: { email: userData.email },
+			// update:{} intentionally leaves existing users unchanged on re-seed.
+			// To reset a user's password or role, delete the row first or update the create block.
+			update: {},
+			create: {
+				email: userData.email,
+				name: userData.name,
+				role: userData.role,
+				password: hashed,
+				image: `https://api.dicebear.com/7.x/avataaars/svg?seed=${userData.email}`,
 			},
+		});
+		seeded.push(user);
+		console.log(`  ✓ User: ${user.email} (${user.role})`);
+	}
+	return seeded;
+}
+
+async function seedDevData(users) {
+	// Audit logs — representative actions per user
+	const actions = ["user.login", "user.update", "file.upload"];
+	const userIds = users.map((u) => u.id);
+	// Scoped to seeded user IDs so real audit entries in a shared dev DB are not wiped.
+	await prisma.auditLog.deleteMany({
+		where: { userId: { in: userIds }, action: { in: actions } },
+	});
+	for (const user of users) {
+		for (const action of actions) {
+			await prisma.auditLog.create({
+				data: {
+					userId: user.id,
+					action,
+					entity: "User",
+					entityId: user.id,
+					metadata: {
+						ip: faker.internet.ip(),
+						userAgent: faker.internet.userAgent(),
+					},
+				},
+			});
+		}
+	}
+	console.log(`  ✓ AuditLogs: ${users.length * actions.length} rows`);
+
+	// A sample pending job so the worker dashboard has something to show
+	await prisma.job.deleteMany({ where: { name: "seed-example-job" } });
+	await prisma.job.create({
+		data: {
+			queue: "default",
+			name: "seed-example-job",
+			data: { message: "Hello from seed" },
+			status: "PENDING",
 		},
 	});
+	console.log("  ✓ Job: seed-example-job (PENDING)");
+}
+
+// ---------------------------------------------------------------------------
+// Add your own model seeders below and call them from main()
+// Example:
+//   async function seedTeams(users) {
+//     await prisma.team.upsert({ where: { slug: "acme" }, update: {}, create: { ... } });
+//   }
+// ---------------------------------------------------------------------------
+
+async function main() {
+	console.log(`\nSeeding database [profile: ${PROFILE}]...\n`);
+
+	const users = await seedUsers();
+
+	if (PROFILE === "dev") {
+		await seedDevData(users);
+	}
+
+	// Add your seeders here:
+	// await seedTeams(users);
 
-	console.log("Seeded user:", user.email);
+	console.log("\nDone.\n");
 }
 
 main()

package/templates/base-project/packages/db/src/client.js

@@ -1,24 +1,7 @@
 import { PrismaPg } from "@prisma/adapter-pg";
+import { getConnectionString } from "./connection.js";
 import { PrismaClient } from "./generated/prisma/client.ts";
 
-/**
- * Builds a Postgres connection string from individual env vars (mirrors prisma.config.ts).
- * Throws if any required variable is missing — but only when actually called,
- * so the module can be safely imported at build time (e.g. during `next build`).
- */
-function getConnectionString() {
-	const user = process.env.POSTGRES_USER;
-	if (!user) throw new Error("POSTGRES_USER environment variable is required");
-	const password = process.env.POSTGRES_PASSWORD;
-	if (!password)
-		throw new Error("POSTGRES_PASSWORD environment variable is required");
-	const host = process.env.POSTGRES_HOST || "localhost";
-	const port = process.env.POSTGRES_PORT || "5432";
-	const db = process.env.POSTGRES_DB;
-	if (!db) throw new Error("POSTGRES_DB environment variable is required");
-	return `postgresql://${user}:${password}@${host}:${port}/${db}?schema=public`;
-}
-
 /**
  * Returns the connection pool configuration for the `pg` driver.
  *

package/templates/base-project/packages/db/src/connection.js

@@ -0,0 +1,44 @@
+/**
+ * Shared connection string builder for PostgreSQL.
+ * Used by both the Prisma client (client.js) and Prisma CLI (prisma.config.ts).
+ *
+ * Priority: DATABASE_URL env var → assembled from POSTGRES_* env vars.
+ *
+ * @param {{ throwOnMissing?: boolean }} [options]
+ *   - throwOnMissing=true  (default) — runtime: throws if credentials are missing.
+ *   - throwOnMissing=false — CLI/CI: returns a placeholder URL so `prisma generate` works.
+ * @returns {string} PostgreSQL connection string
+ */
+export function getConnectionString({ throwOnMissing = true } = {}) {
+	// 1. Prefer an explicit DATABASE_URL if set
+	if (process.env.DATABASE_URL) {
+		return process.env.DATABASE_URL;
+	}
+
+	// 2. Assemble from individual POSTGRES_* vars
+	const user = process.env.POSTGRES_USER;
+	const password = process.env.POSTGRES_PASSWORD;
+	const host = process.env.POSTGRES_HOST || "localhost";
+	const port = process.env.POSTGRES_PORT || "5432";
+	const db = process.env.POSTGRES_DB;
+
+	const hasCredentials = user && password && db;
+
+	if (!hasCredentials) {
+		if (throwOnMissing) {
+			const missing = [];
+			if (!user) missing.push("POSTGRES_USER");
+			if (!password) missing.push("POSTGRES_PASSWORD");
+			if (!db) missing.push("POSTGRES_DB");
+			throw new Error(
+				`Missing required database environment variables: ${missing.join(", ")}. ` +
+					"Set DATABASE_URL or the individual POSTGRES_* variables.",
+			);
+		}
+
+		// Placeholder for prisma generate / CI — will fail at connect time, not at config time.
+		return "postgresql://placeholder:placeholder@localhost:5432/placeholder?schema=public";
+	}
+
+	return `postgresql://${user}:${password}@${host}:${port}/${db}?schema=public`;
+}

package/templates/base-project/packages/db/src/connection.test.js

@@ -0,0 +1,119 @@
+import assert from "node:assert";
+import { afterEach, beforeEach, describe, test } from "node:test";
+import { getConnectionString } from "./connection.js";
+
+describe("getConnectionString", () => {
+	const originalEnv = { ...process.env };
+
+	beforeEach(() => {
+		// Clear all DB-related env vars before each test
+		delete process.env.DATABASE_URL;
+		delete process.env.POSTGRES_USER;
+		delete process.env.POSTGRES_PASSWORD;
+		delete process.env.POSTGRES_HOST;
+		delete process.env.POSTGRES_PORT;
+		delete process.env.POSTGRES_DB;
+	});
+
+	afterEach(() => {
+		// Restore original env
+		process.env = { ...originalEnv };
+	});
+
+	test("returns DATABASE_URL when set", () => {
+		process.env.DATABASE_URL =
+			"postgresql://user:pass@remote:5433/mydb?schema=public";
+		const url = getConnectionString();
+		assert.strictEqual(url, process.env.DATABASE_URL);
+	});
+
+	test("DATABASE_URL takes priority over individual POSTGRES_* vars", () => {
+		process.env.DATABASE_URL =
+			"postgresql://url_user:url_pass@remote:5433/url_db?schema=public";
+		process.env.POSTGRES_USER = "individual_user";
+		process.env.POSTGRES_PASSWORD = "individual_pass";
+		process.env.POSTGRES_DB = "individual_db";
+
+		const url = getConnectionString();
+		assert.strictEqual(url, process.env.DATABASE_URL);
+	});
+
+	test("assembles from POSTGRES_* vars when DATABASE_URL is not set", () => {
+		process.env.POSTGRES_USER = "test_user";
+		process.env.POSTGRES_PASSWORD = "test_pass";
+		process.env.POSTGRES_DB = "test_db";
+
+		const url = getConnectionString();
+		assert.strictEqual(
+			url,
+			"postgresql://test_user:test_pass@localhost:5432/test_db?schema=public",
+		);
+	});
+
+	test("uses custom host and port when provided", () => {
+		process.env.POSTGRES_USER = "user";
+		process.env.POSTGRES_PASSWORD = "pass";
+		process.env.POSTGRES_HOST = "db.example.com";
+		process.env.POSTGRES_PORT = "5433";
+		process.env.POSTGRES_DB = "mydb";
+
+		const url = getConnectionString();
+		assert.strictEqual(
+			url,
+			"postgresql://user:pass@db.example.com:5433/mydb?schema=public",
+		);
+	});
+
+	test("throws when POSTGRES_USER is missing (throwOnMissing=true)", () => {
+		process.env.POSTGRES_PASSWORD = "pass";
+		process.env.POSTGRES_DB = "db";
+
+		assert.throws(() => getConnectionString(), {
+			message: /POSTGRES_USER/,
+		});
+	});
+
+	test("throws when POSTGRES_PASSWORD is missing (throwOnMissing=true)", () => {
+		process.env.POSTGRES_USER = "user";
+		process.env.POSTGRES_DB = "db";
+
+		assert.throws(() => getConnectionString(), {
+			message: /POSTGRES_PASSWORD/,
+		});
+	});
+
+	test("throws when POSTGRES_DB is missing (throwOnMissing=true)", () => {
+		process.env.POSTGRES_USER = "user";
+		process.env.POSTGRES_PASSWORD = "pass";
+
+		assert.throws(() => getConnectionString(), {
+			message: /POSTGRES_DB/,
+		});
+	});
+
+	test("lists all missing vars in error message", () => {
+		assert.throws(() => getConnectionString(), {
+			message: /POSTGRES_USER.*POSTGRES_PASSWORD.*POSTGRES_DB/,
+		});
+	});
+
+	test("returns placeholder when throwOnMissing=false and vars missing", () => {
+		const url = getConnectionString({ throwOnMissing: false });
+		assert.strictEqual(
+			url,
+			"postgresql://placeholder:placeholder@localhost:5432/placeholder?schema=public",
+		);
+	});
+
+	test("still assembles correctly with throwOnMissing=false when vars present", () => {
+		process.env.POSTGRES_USER = "user";
+		process.env.POSTGRES_PASSWORD = "pass";
+		process.env.POSTGRES_DB = "db";
+
+		const url = getConnectionString({ throwOnMissing: false });
+		assert.strictEqual(
+			url,
+			"postgresql://user:pass@localhost:5432/db?schema=public",
+		);
+	});
+});

package/templates/base-project/packages/db/src/queries.js

@@ -15,6 +15,8 @@ const USER_SAFE_SELECT = {
 	updatedAt: true,
 };
 
+export { USER_SAFE_SELECT };
+
 // User queries
 export const user = {
 	findById: (id) => {
@@ -23,12 +25,7 @@ export const user = {
 			select: USER_SAFE_SELECT,
 		});
 	},
-	findByIdWithPosts: (id) => {
-		return prisma.user.findUnique({
-			where: { id },
-			select: { ...USER_SAFE_SELECT, posts: true },
-		});
-	},
+
 	/**
 	 * findByEmail returns ALL fields including password.
 	 * Only use for internal auth — never expose the result directly to clients.
@@ -67,69 +64,6 @@ export const user = {
 	},
 };
 
-/**
- * Safe author include — returns author without sensitive fields.
- */
-const AUTHOR_SAFE_INCLUDE = { author: { select: USER_SAFE_SELECT } };
-
-// Post queries
-export const post = {
-	findById: (id) => {
-		return prisma.post.findUnique({
-			where: { id },
-			include: AUTHOR_SAFE_INCLUDE,
-		});
-	},
-	findAll: (options = {}) => {
-		const { skip = 0, take = 10, where, orderBy } = options;
-		return prisma.post.findMany({
-			where,
-			skip,
-			take,
-			include: AUTHOR_SAFE_INCLUDE,
-			orderBy: orderBy || { createdAt: "desc" },
-		});
-	},
-	findPublished: (options = {}) => {
-		const { skip = 0, take = 10 } = options;
-		return prisma.post.findMany({
-			where: { published: true },
-			skip,
-			take,
-			include: AUTHOR_SAFE_INCLUDE,
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	findByAuthor: (authorId, options = {}) => {
-		const { skip = 0, take = 10 } = options;
-		return prisma.post.findMany({
-			where: { authorId },
-			skip,
-			take,
-			include: AUTHOR_SAFE_INCLUDE,
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	create: (data) => {
-		return prisma.post.create({
-			data,
-			include: AUTHOR_SAFE_INCLUDE,
-		});
-	},
-	update: (id, data) => {
-		return prisma.post.update({
-			where: { id },
-			data,
-			include: AUTHOR_SAFE_INCLUDE,
-		});
-	},
-	delete: (id) => {
-		return prisma.post.delete({
-			where: { id },
-		});
-	},
-};
-
 // Note: Job tracking is handled by BullMQ's built-in Redis persistence.
 // The Prisma Job model is retained in the schema for optional audit/reporting
 // but these query helpers have been removed to avoid confusion with BullMQ.
@@ -231,6 +165,55 @@ export const verificationToken = {
 	},
 };
 
+// AuditLog queries
+export const auditLog = {
+	findAll: (options = {}) => {
+		const { skip = 0, take = 50 } = options;
+		return prisma.auditLog.findMany({
+			skip,
+			take,
+			include: { user: { select: { id: true, email: true, name: true } } },
+			orderBy: { createdAt: "desc" },
+		});
+	},
+	findByUserId: (userId, options = {}) => {
+		const { skip = 0, take = 50 } = options;
+		return prisma.auditLog.findMany({
+			where: { userId },
+			skip,
+			take,
+			include: { user: { select: { id: true, email: true, name: true } } },
+			orderBy: { createdAt: "desc" },
+		});
+	},
+	findByEntity: (entity, options = {}) => {
+		const { skip = 0, take = 50 } = options;
+		return prisma.auditLog.findMany({
+			where: { entity },
+			skip,
+			take,
+			include: { user: { select: { id: true, email: true, name: true } } },
+			orderBy: { createdAt: "desc" },
+		});
+	},
+	findByAction: (action, options = {}) => {
+		const { skip = 0, take = 50 } = options;
+		return prisma.auditLog.findMany({
+			where: { action },
+			skip,
+			take,
+			include: { user: { select: { id: true, email: true, name: true } } },
+			orderBy: { createdAt: "desc" },
+		});
+	},
+	create: (data) => {
+		return prisma.auditLog.create({
+			data,
+			include: { user: { select: { id: true, email: true, name: true } } },
+		});
+	},
+};
+
 // File queries
 export const file = {
 	create: (data) => {
@@ -285,52 +268,3 @@ export const file = {
 		return prisma.file.count({ where });
 	},
 };
-
-// AuditLog queries
-export const auditLog = {
-	findAll: (options = {}) => {
-		const { skip = 0, take = 50 } = options;
-		return prisma.auditLog.findMany({
-			skip,
-			take,
-			include: { user: { select: { id: true, email: true, name: true } } },
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	findByUserId: (userId, options = {}) => {
-		const { skip = 0, take = 50 } = options;
-		return prisma.auditLog.findMany({
-			where: { userId },
-			skip,
-			take,
-			include: { user: { select: { id: true, email: true, name: true } } },
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	findByEntity: (entity, options = {}) => {
-		const { skip = 0, take = 50 } = options;
-		return prisma.auditLog.findMany({
-			where: { entity },
-			skip,
-			take,
-			include: { user: { select: { id: true, email: true, name: true } } },
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	findByAction: (action, options = {}) => {
-		const { skip = 0, take = 50 } = options;
-		return prisma.auditLog.findMany({
-			where: { action },
-			skip,
-			take,
-			include: { user: { select: { id: true, email: true, name: true } } },
-			orderBy: { createdAt: "desc" },
-		});
-	},
-	create: (data) => {
-		return prisma.auditLog.create({
-			data,
-			include: { user: { select: { id: true, email: true, name: true } } },
-		});
-	},
-};

package/templates/base-project/packages/db/src/queries.test.js

@@ -7,10 +7,6 @@ const _mockPrisma = {
 		findUnique: async (params) => params,
 		create: async (params) => params,
 	},
-	post: {
-		create: async (params) => params,
-		findMany: async (params) => params,
-	},
 };
 
 // Mock module for queries
@@ -31,15 +27,6 @@ const mockQueries = {
 			...data,
 		}),
 	},
-	post: {
-		create: async (data) => ({
-			id: "1",
-			...data,
-		}),
-		findPublished: async () => [
-			{ id: "1", title: "Published", published: true },
-		],
-	},
 };
 
 test("User Queries - findById calls prisma with correct params", async () => {
@@ -61,19 +48,3 @@ test("User Queries - create calls prisma with correct params", async () => {
 	assert.strictEqual(result.email, "new@example.com");
 	assert.strictEqual(result.name, "New User");
 });
-
-test("Post Queries - create calls prisma with correct params", async () => {
-	const result = await mockQueries.post.create({
-		title: "Test Post",
-		authorId: "1",
-	});
-	assert.strictEqual(result.title, "Test Post");
-	assert.strictEqual(result.authorId, "1");
-});
-
-test("Post Queries - findPublished returns only published posts", async () => {
-	const result = await mockQueries.post.findPublished();
-	assert.ok(Array.isArray(result));
-	assert.strictEqual(result.length, 1);
-	assert.strictEqual(result[0].published, true);
-});

package/templates/base-project/packages/db/src/schemas.js

@@ -23,18 +23,6 @@ export const userUpdateSchema = z.object({
 	image: z.string().url().optional(),
 });
 
-export const postCreateSchema = z.object({
-	title: z.string().min(1, "Title is required"),
-	content: z.string().optional(),
-	published: z.boolean().optional(),
-});
-
-export const postUpdateSchema = z.object({
-	title: z.string().min(1, "Title is required").optional(),
-	content: z.string().optional(),
-	published: z.boolean().optional(),
-});
-
 export const fileUploadSchema = z.object({
 	filename: z.string().min(1, "Filename is required"),
 	mimeType: z.string().min(1, "MIME type is required"),

package/templates/base-project/pnpm-workspace.yaml

@@ -5,3 +5,7 @@ packages:
 onlyBuiltDependencies:
   - '@prisma/engines'
   - prisma
+  - esbuild
+  - msgpackr-extract
+  - sharp
+  - simple-git-hooks

package/templates/base-project/turbo.json

@@ -26,9 +26,11 @@
 		"db:seed": {
 			"cache": false
 		},
-		"db:studio": {
-			"cache": false,
-			"persistent": true
+		"sync-templates": {
+			"cache": false
+		},
+		"sync-templates:check": {
+			"cache": false
 		},
 		"dev": {
 			"cache": false,

package/templates/config/package.json

@@ -5,6 +5,8 @@
 	"exports": {
 		".": "./src/index.js",
 		"./app-url": "./src/app-url.js",
+		"./environment": "./src/environment.js",
+		"./load-config": "./src/load-config.js",
 		"./validate-env": "./src/validate-env.js"
 	}
 }