@shivaedev/create-app 0.37.0 → 0.38.0

package/src/resource/contract.ts

@@ -0,0 +1,38 @@
+import type { ResourceNames } from "./names.ts";
+
+export function resourceContract({ name, pascal, table }: ResourceNames) {
+	return `import { Option, Schema } from "effect";
+import { Model } from "effect/schema";
+import { collection } from "@shivaedev/changes/keys.ts";
+import { contract } from "@shivaedev/contract/contract.ts";
+import { command, query } from "@shivaedev/contract/operation.ts";
+import { signedIn } from "@shivaedev/contract/readPolicy.ts";
+import { fieldRejection } from "@shivaedev/contract/rejection.ts";
+import { InternalServerError, ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
+import { AuthenticatedUser } from "@shivaedev/identity/middleware.ts";
+
+export class Item extends Model.Class<Item>("${pascal}Item")({
+	id: Model.Field({ json: Schema.Number, select: Schema.Number, update: Schema.Number }),
+	title: Schema.Trim.check(Schema.isNonEmpty({ message: "Enter a title" })),
+}) {}
+
+export const Fields = Schema.Struct({ title: Item.fields.title });
+export const keys = collection("${table}", Schema.Number, { userId: Schema.String });
+
+export const List = query("list", {
+	readPolicy: signedIn,
+	reads: (_input, viewer) => (Option.isSome(viewer) ? [keys.bucket.userId(viewer.value.id)] : []),
+	rejections: { InternalServerError, ServiceUnavailable },
+	success: Schema.Array(Item.json),
+});
+
+export const Create = command("create", {
+	invalidates: () => [],
+	payload: Fields,
+	rejections: { InternalServerError, Invalid: fieldRejection(Fields), ServiceUnavailable },
+	success: Item.json,
+});
+
+export const ${pascal}Contract = contract("${name}", { commands: [Create], queries: [List] }).middleware(AuthenticatedUser);
+`;
+}

package/src/resource/files.ts

@@ -0,0 +1,19 @@
+import { resourceContract } from "./contract.ts";
+import { resourceKit, resourceStory } from "./kit.ts";
+import type { ResourceNames } from "./names.ts";
+import { resourceMigration, resourceRepository, resourceService } from "./persistence.ts";
+import { resourceClient, resourceRegistration } from "./registration.ts";
+
+export function resourceFiles(names: ResourceNames, migration: string) {
+	const root = `src/modules/${names.name}`;
+	return {
+		[`${root}/${names.name}.ts`]: resourceContract(names),
+		[`${root}/client/make.ts`]: resourceClient(names),
+		[`${root}/server/makeRepository.ts`]: resourceRepository(names),
+		[`${root}/server/migrations/${migration}_${names.table}.ts`]: resourceMigration(names),
+		[`${root}/server/registration.ts`]: resourceRegistration(names),
+		[`${root}/server/Service.ts`]: resourceService(names),
+		[`${root}/server/lifecycle.spec.ts`]: resourceStory(names),
+		[`${root}/test-support/application.ts`]: resourceKit(names),
+	};
+}

package/src/resource/kit.ts

@@ -0,0 +1,109 @@
+import type { ResourceNames } from "./names.ts";
+
+export function resourceKit({ name, pascal, table }: ResourceNames) {
+	return `import { layerWebSocketConstructorWS } from "@effect/platform-node/NodeSocket";
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { withIsolatedDatabase } from "@shivaedev/test-sql/server/withIsolatedDatabase.ts";
+import { storyKit } from "@shivaedev/test-story/server/storyKit.ts";
+import { make${pascal}Client } from "#modules/${name}/client/make.ts";
+import { startHost } from "#test-support/host.ts";
+import { postgres } from "#test-support/postgres.ts";
+import { mintUser } from "#test-support/sessionPrecondition.ts";
+
+type Client = Effect.Success<ReturnType<typeof make${pascal}Client>["client"]>;
+
+export const app = storyKit({
+	around: withIsolatedDatabase,
+	clock: "live",
+	*create() {
+		const host = yield* startHost();
+		return { accounts: new Map<string, Client>(), host };
+	},
+	inspect: (engine) => ({ accounts: [...engine.accounts.keys()], baseUrl: engine.host.baseUrl }),
+	layer: postgres,
+	name: "${name}",
+	stages: ["accounts", "items"],
+	verbs: (engine, story) => ({
+		itemsOf: (name: string) => {
+			const client = engine.accounts.get(name);
+			if (client === undefined) {
+				throw new Error(\`Give the story signedIn("\${name}")\`);
+			}
+			return {
+				create: (title: string) => {
+					story.tell(\`\${name} creates \${JSON.stringify(title)}\`);
+					return client["${name}.create"]({ title });
+				},
+				list: () => {
+					story.tell(\`\${name} lists ${name}\`);
+					return client["${name}.list"]();
+				},
+			};
+		},
+		storedTitles: () =>
+			Effect.gen(function* () {
+				const sql = yield* SqlClient.SqlClient;
+				const rows = yield* sql<{ title: string }>\`select title from \${sql("${table}")} order by id desc\`;
+				return rows.map((row) => row.title);
+			}),
+		visitorClient: () => make${pascal}Client(\`\${engine.host.baseUrl}/rpc\`, { webSocketConstructor: layerWebSocketConstructorWS }).client,
+	}),
+});
+
+export function signedIn(name: string) {
+	return app.trait("accounts", \`\${name} is signed in\`, function* (engine) {
+		const { headers } = yield* mintUser(engine.host, name);
+		const client = yield* make${pascal}Client(\`\${engine.host.baseUrl}/rpc\`, {
+			headers: { cookie: headers.get("cookie") ?? "", origin: engine.host.origin },
+			webSocketConstructor: layerWebSocketConstructorWS,
+		}).client;
+		engine.accounts.set(name, client);
+	});
+}
+`;
+}
+
+export function resourceStory({ name }: ResourceNames) {
+	return `import { expect } from "vitest";
+import { outcomes } from "@shivaedev/test-story/server/outcomes.ts";
+import { app, signedIn } from "#modules/${name}/test-support/application.ts";
+import { answer } from "#test-support/answers.ts";
+
+app.it("alice creates an item, lists it and persists it in PostgreSQL", [signedIn("alice")], function* ({ itemsOf, storedTitles }) {
+	expect(yield* itemsOf("alice").list()).toEqual([]);
+
+	const item = yield* itemsOf("alice").create("First item");
+
+	expect(item.title).toBe("First item");
+	yield* outcomes([
+		["alice's list", () => itemsOf("alice").list(), [{ id: item.id, title: "First item" }]],
+		["stored titles", () => storedTitles(), ["First item"]],
+	]);
+});
+
+app.it("bob cannot list alice's items", [signedIn("alice"), signedIn("bob")], function* ({ itemsOf }) {
+	yield* itemsOf("alice").create("Alice's private item");
+
+	const listed = yield* itemsOf("bob").list();
+
+	expect(listed).toEqual([]);
+});
+
+app.it("a visitor cannot create items", [], function* ({ visitorClient }) {
+	const client = yield* visitorClient();
+
+	const replied = yield* answer(client["${name}.create"]({ title: "Anonymous item" }));
+
+	expect(replied).toBe("sign in required");
+});
+
+app.it("a visitor cannot list items", [], function* ({ visitorClient }) {
+	const client = yield* visitorClient();
+
+	const replied = yield* answer(client["${name}.list"]());
+
+	expect(replied).toBe("sign in required");
+});
+`;
+}

package/src/resource/names.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { CreateAppError } from "#CreateAppError.ts";
+
+export const resourceNames = Effect.fn("CreateApp.resourceNames")(function* (name: string) {
+	if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(name) || name.length > 63) {
+		return yield* new CreateAppError({ message: "Use a lowercase resource name with optional hyphens, at most 63 characters long." });
+	}
+	const words = name.split("-");
+	const pascal = words.map((word) => word[0]?.toUpperCase() + word.slice(1)).join("");
+	return { camel: pascal[0]?.toLowerCase() + pascal.slice(1), name, pascal, table: words.join("_") };
+});
+
+export type ResourceNames = Effect.Success<ReturnType<typeof resourceNames>>;

package/src/resource/persistence.ts

@@ -0,0 +1,67 @@
+import type { ResourceNames } from "./names.ts";
+
+export function resourceRepository({ name, pascal, table }: ResourceNames) {
+	return `import { Schema } from "effect";
+import { Model } from "effect/schema";
+import { bucket } from "@shivaedev/changes/buckets.ts";
+import { makeRepository } from "@shivaedev/sql/repository.ts";
+import { Item, keys } from "#modules/${name}/${name}.ts";
+
+export class StoredItem extends Model.Class<StoredItem>("Stored${pascal}Item")({
+	...Model.fields(Item),
+	userId: bucket(Schema.String),
+}) {}
+
+export const make${pascal}Repository = makeRepository(StoredItem, {
+	collection: keys,
+	idColumn: "id",
+	spanPrefix: "${pascal}",
+	tableName: "${table}",
+});
+`;
+}
+
+export function resourceService({ name, pascal }: ResourceNames) {
+	return `import { Effect } from "effect";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import { SqlClient } from "effect/sql";
+import type { SqlError } from "effect/sql/SqlError";
+import { ServiceUnavailable } from "@shivaedev/errors/taxonomy.ts";
+import { defineService } from "@shivaedev/service/defineService.ts";
+import { transact } from "@shivaedev/sql/transact.ts";
+import type { Create } from "#modules/${name}/${name}.ts";
+import { make${pascal}Repository } from "./makeRepository.ts";
+
+const unavailable = (cause: SqlError) => Object.assign(new ServiceUnavailable({ message: "Could not reach the ${name} database" }), { cause });
+
+export const ${pascal}Service = defineService({
+	id: "app/${pascal}Service",
+	initialize: make${pascal}Repository,
+	methods: (repository) => ({
+		create: (input: typeof Create.payload.Type, userId: string) =>
+			repository.insert({ ...input, userId }).pipe(transact({ onSqlError: unavailable })),
+		list: (userId: string) =>
+			repository
+				.findMany({ orderBy: { direction: "desc", field: "id" }, select: ["id", "title"], where: { userId } })
+				.pipe(Effect.catchTag("SqlError", (cause) => Effect.fail(unavailable(cause)))),
+	}),
+	requires: [SqlClient.SqlClient, Reactivity.Reactivity],
+});
+`;
+}
+
+export function resourceMigration({ table }: ResourceNames) {
+	return `import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { userReference } from "@shivaedev/identity/server/better-auth/userReference.ts";
+
+export default Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql\`create table \${sql("${table}")} (
+		id serial primary key,
+		title text not null,
+		user_id text not null references \${sql(userReference.table)} (\${sql(userReference.column)}) on delete cascade
+	)\`;
+});
+`;
+}

package/src/resource/registration.ts

@@ -0,0 +1,48 @@
+import type { ResourceNames } from "./names.ts";
+
+export function resourceRegistration({ name, camel, pascal }: ResourceNames) {
+	return `import { resolve } from "node:path";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { Effect } from "effect";
+import { Migrator } from "effect/sql";
+import { rpcBoundary } from "@shivaedev/errors/boundary.ts";
+import { InternalServerError } from "@shivaedev/errors/taxonomy.ts";
+import { SessionUser } from "@shivaedev/identity/identity.ts";
+import type { AppModule } from "@shivaedev/server/AppModule.ts";
+import { Create, List, ${pascal}Contract } from "#modules/${name}/${name}.ts";
+import { ${pascal}Service } from "./Service.ts";
+
+const boundaryOptions = { unexpected: (message: string) => new InternalServerError({ message }) };
+
+const handlers = ${pascal}Contract.application.toLayer(
+	Effect.gen(function* () {
+		const service = yield* ${pascal}Service;
+		return ${pascal}Contract.application.of({
+			"${name}.create": (input) =>
+				Effect.flatMap(SessionUser, ({ id }) => service.create(input, id).pipe(rpcBoundary(Create.error, boundaryOptions))),
+			"${name}.list": () => Effect.flatMap(SessionUser, ({ id }) => service.list(id).pipe(rpcBoundary(List.error, boundaryOptions))),
+		});
+	}),
+);
+
+export const ${camel}Registration = {
+	group: ${pascal}Contract,
+	handlers,
+	migrations: { loader: Migrator.fromFileSystem(resolve(import.meta.dirname, "migrations")).pipe(Effect.provide(NodeServices.layer)) },
+	name: "${name}",
+	services: ${pascal}Service.layer,
+} satisfies AppModule;
+`;
+}
+
+export function resourceClient({ name, pascal }: ResourceNames) {
+	return `import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { makeClient } from "@shivaedev/contract/bind.ts";
+import type { ClientOptions } from "@shivaedev/contract/clientOptions.ts";
+import { ${pascal}Contract } from "#modules/${name}/${name}.ts";
+
+export function make${pascal}Client(url: string, options: Omit<ClientOptions, "url"> & { readonly registry?: AtomRegistry.AtomRegistry } = {}) {
+	return makeClient(${pascal}Contract, { url, ...options });
+}
+`;
+}

package/src/template.ts

@@ -14,13 +14,21 @@ export function appTemplate(template: Template, minimal = false): Template {
 		return files;
 	}
 	return files
-		.filter((entry) => !entry.path.startsWith("src/modules/notes/"))
+		.filter((entry) => !(entry.path.startsWith("src/modules/notes/") || entry.path.startsWith("tooling/notes/")))
 		.map((entry) => {
 			if (entry.path === "package.json" && minimalManifest !== undefined) {
 				return { ...entry, content: minimalManifest.content };
 			}
 			// Updates must reconstruct historical minimal files exactly to recognize unmodified deletions.
-			if (!["src/admin/modules.ts", "src/server/modules.ts", "src/server/workerModules.ts", "src/client/modules.ts"].includes(entry.path)) {
+			if (
+				![
+					"src/admin/foundation.ts",
+					"src/admin/modules.ts",
+					"src/server/modules.ts",
+					"src/server/workerModules.ts",
+					"src/client/modules.ts",
+				].includes(entry.path)
+			) {
 				return entry;
 			}
 			const source = Buffer.from(entry.content, "base64")
@@ -89,7 +97,11 @@ export function prepareManifest(source: string, versions: Readonly<Record<string
 			versions,
 		),
 		devDependencies: registryDependencies(manifest.devDependencies, versions),
-		scripts: Object.fromEntries(Object.entries(scripts).map(([name, script]) => [name, script.replaceAll("--conditions=source ", "")])),
+		scripts: Object.fromEntries(
+			Object.entries(scripts)
+				.filter(([name]) => !minimal || name !== "browser-check:live-notes")
+				.map(([name, script]) => [name, script.replaceAll("--conditions=source ", "")]),
+		),
 	};
 	return manifestJson(prepared);
 }