@automateinc/fleet-types 1.0.98 → 1.0.100

package/.env.example

@@ -0,0 +1,2 @@
+FLEET_API_PATH=../fleet-api
+FLEET_API_TYPES_PATH=dist/types/trpc.d.ts

package/README.md

@@ -15,3 +15,22 @@ npm i @automateinc/fleet-types
 ```js
 import { IAttendance } from "@automateinc/fleet-types";
 ```
+
+## Generating tRPC Types
+
+When running the CLI from a consuming project such as `fleet-web`, configure the Fleet API source and generated
+type destination in that project's `.env`:
+
+```dotenv
+FLEET_API_PATH=../fleet-api
+FLEET_API_TYPES_PATH=api/types.d.ts
+```
+
+Both paths are resolved relative to the directory where the command is run. Generate the declaration from Fleet
+API's `AppRouter` with:
+
+```bash
+npx @automateinc/fleet-types generate
+```
+
+Inside the `fleet-types` repository, `npm run generate:trpc-types` remains available as a convenience alias.

package/bin/fleet-types.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { loadEnvFile } from "node:process";
+import { fileURLToPath } from "node:url";
+
+const command = process.argv[2];
+
+if (!command || command === "--help" || command === "-h") {
+	printUsage();
+} else if (command !== "generate") {
+	console.error(`Unknown command: ${command}\n`);
+	printUsage();
+	process.exitCode = 1;
+} else {
+	try {
+		await generateTypes();
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : error);
+		process.exitCode = 1;
+	}
+}
+
+async function generateTypes() {
+	const callerRoot = process.cwd();
+	const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+	try {
+		loadEnvFile(path.join(callerRoot, ".env"));
+	} catch (error) {
+		if (error?.code !== "ENOENT") {
+			throw error;
+		}
+	}
+
+	const fleetApiPath = process.env.FLEET_API_PATH;
+	if (!fleetApiPath) {
+		throw new Error("FLEET_API_PATH is not set. Add it to .env or the process environment.");
+	}
+
+	const fleetApiTypesPath = process.env.FLEET_API_TYPES_PATH;
+	if (!fleetApiTypesPath) {
+		throw new Error("FLEET_API_TYPES_PATH is not set. Add it to .env or the process environment.");
+	}
+
+	const apiRoot = path.resolve(callerRoot, fleetApiPath);
+	const outputPath = path.resolve(callerRoot, fleetApiTypesPath);
+	const routerSourcePath = path.join(apiRoot, "src/services/trpc/index.ts");
+	const prismaTypesPath = path.join(apiRoot, "prisma/types.d.ts");
+	const executableExtension = process.platform === "win32" ? ".cmd" : "";
+	const apiTscPath = path.join(apiRoot, `node_modules/.bin/tsc${executableExtension}`);
+	const biomePath = path.join(packageRoot, `node_modules/.bin/biome${executableExtension}`);
+	const temporaryDirectory = await mkdtemp(path.join(tmpdir(), "fleet-trpc-types-"));
+	const declarationOutputDirectory = path.join(temporaryDirectory, "declarations");
+	const declarationTsconfigPath = path.join(temporaryDirectory, "tsconfig.json");
+	const prismaJsonShimPath = path.join(temporaryDirectory, "prisma-json.d.ts");
+	const serviceProviderShimPath = path.join(temporaryDirectory, "service-provider.d.ts");
+	const requireFromPackage = createRequire(path.join(packageRoot, "package.json"));
+	const ts = requireFromPackage("typescript");
+
+	try {
+		const prismaTypesContent = await readFile(prismaTypesPath, "utf8");
+		const prismaTypesSource = ts.createSourceFile(prismaTypesPath, prismaTypesContent, ts.ScriptTarget.Latest, true);
+		let coordsType;
+		const findCoordsType = node => {
+			if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === "PrismaJson") {
+				const body = node.body;
+				if (body && ts.isModuleBlock(body)) {
+					coordsType = body.statements.find(
+						statement => ts.isTypeAliasDeclaration(statement) && statement.name.text === "Coords",
+					);
+				}
+			}
+			ts.forEachChild(node, findCoordsType);
+		};
+		findCoordsType(prismaTypesSource);
+		if (!coordsType) {
+			throw new Error(`PrismaJson.Coords was not found in ${prismaTypesPath}.`);
+		}
+		const coordsTypeDeclaration = ts
+			.createPrinter({ newLine: ts.NewLineKind.LineFeed })
+			.printNode(ts.EmitHint.Unspecified, coordsType, prismaTypesSource);
+
+		await writeFile(
+			prismaJsonShimPath,
+			`export {};\ndeclare global { namespace PrismaJson { ${coordsTypeDeclaration} } }\n`,
+		);
+		await writeFile(
+			serviceProviderShimPath,
+			"export declare class ServiceProvider { static getEncryptionService(): { decodeId(encodedId: string, prefix: string): number }; }\n",
+		);
+		await writeFile(
+			declarationTsconfigPath,
+			`${JSON.stringify(
+				{
+					compilerOptions: {
+						declaration: true,
+						declarationMap: false,
+						emitDeclarationOnly: true,
+						incremental: true,
+						noEmit: false,
+						outDir: declarationOutputDirectory,
+						paths: {
+							"@/*": [path.join(apiRoot, "src/*")],
+							"@/providers/service.provider": [serviceProviderShimPath],
+						},
+						tsBuildInfoFile: path.join(temporaryDirectory, "tsconfig.tsbuildinfo"),
+						typeRoots: [path.join(apiRoot, "node_modules/@types")],
+					},
+					extends: path.join(apiRoot, "tsconfig.json"),
+					files: [routerSourcePath, prismaJsonShimPath],
+				},
+				null,
+				2,
+			)}\n`,
+		);
+
+		const typeScriptResult = spawnSync(apiTscPath, ["--project", declarationTsconfigPath, "--pretty"], {
+			cwd: apiRoot,
+			stdio: "inherit",
+		});
+
+		if (typeScriptResult.error) {
+			throw typeScriptResult.error;
+		}
+		if (typeScriptResult.status !== 0) {
+			throw new Error(`TypeScript declaration generation failed with exit code ${typeScriptResult.status}.`);
+		}
+
+		const emittedPath = path.join(declarationOutputDirectory, "services/trpc.service.d.ts");
+		const emittedDeclaration = await readFile(emittedPath, "utf8");
+		const sourceFile = ts.createSourceFile(emittedPath, emittedDeclaration, ts.ScriptTarget.Latest, true);
+		const statements = sourceFile.statements.filter(
+			statement =>
+				ts.isImportDeclaration(statement) ||
+				ts.isImportEqualsDeclaration(statement) ||
+				(ts.isVariableStatement(statement) &&
+					statement.declarationList.declarations.some(
+						declaration => ts.isIdentifier(declaration.name) && declaration.name.text === "appRouter",
+					)) ||
+				(ts.isTypeAliasDeclaration(statement) && statement.name.text === "AppRouter"),
+		);
+
+		if (!statements.some(statement => ts.isTypeAliasDeclaration(statement))) {
+			throw new Error("AppRouter was not found in the emitted declaration.");
+		}
+
+		const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+		const appRouterDeclaration = statements
+			.map(statement => printer.printNode(ts.EmitHint.Unspecified, statement, sourceFile))
+			.join("\n")
+			.replace(/^(?: {4})+/gm, indentation => "\t".repeat(indentation.length / 4));
+
+		await mkdir(path.dirname(outputPath), { recursive: true });
+		await writeFile(
+			outputPath,
+			`// Generated by \`npx @automateinc/fleet-types generate\`. Do not edit manually.\n${appRouterDeclaration}\n`,
+		);
+
+		if (existsSync(biomePath)) {
+			const biomeResult = spawnSync(biomePath, ["format", "--write", outputPath], {
+				cwd: callerRoot,
+				stdio: "inherit",
+			});
+			if (biomeResult.error) {
+				throw biomeResult.error;
+			}
+			if (biomeResult.status !== 0) {
+				throw new Error(`Biome formatting failed with exit code ${biomeResult.status}.`);
+			}
+		}
+
+		console.log(`Generated ${path.relative(callerRoot, outputPath)} from ${routerSourcePath}`);
+	} finally {
+		await rm(temporaryDirectory, { force: true, recursive: true });
+	}
+}
+
+function printUsage() {
+	console.log(`Usage: npx @automateinc/fleet-types generate
+
+Commands:
+  generate  Generate AppRouter types from Fleet API
+
+Environment variables:
+  FLEET_API_PATH        Fleet API path relative to the current directory
+  FLEET_API_TYPES_PATH  Generated declaration path relative to the current directory`);
+}

package/package.json

@@ -1,9 +1,13 @@
 {
   "author": "Automate Inc. <hello@automate.bh> (https://automate.bh)",
+  "bin": {
+    "fleet-types": "bin/fleet-types.mjs"
+  },
   "bugs": {
     "url": "https://github.com/automateinc/fleet-types/issues"
   },
   "dependencies": {
+    "@trpc/server": "^11.18.0",
     "asynckit": "^0.4.0",
     "combined-stream": "^1.0.8",
     "delayed-stream": "^1.0.0",
@@ -14,6 +18,7 @@
     "mime-db": "^1.52.0",
     "mime-types": "^2.1.35",
     "proxy-from-env": "^1.1.0",
+    "typescript": "5.7.2",
     "use-sync-external-store": "^1.4.0"
   },
   "description": "Reusable TypeScript types and interfaces for Fleet API.",
@@ -23,8 +28,7 @@
     "@tanstack/react-query": "^4.36.1",
     "axios": "^1.7.9",
     "husky": "^9.1.7",
-    "react": "*",
-    "typescript": "5.1.6"
+    "react": "*"
   },
   "homepage": "https://github.com/automateinc/fleet-types#readme",
   "keywords": [
@@ -48,9 +52,10 @@
   },
   "scripts": {
     "build": "tsc && cp -R src/types dist/",
+    "generate:trpc-types": "node bin/fleet-types.mjs generate",
     "prepare": "husky install",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "types": "dist/types/index.d.ts",
-  "version": "1.0.98"
+  "version": "1.0.100"
 }