@automateinc/fleet-types 1.0.103 → 1.0.105

package/bin/fleet-types.mjs

@@ -2,13 +2,43 @@
 
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, 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 SERIALIZED_OUTPUT_TYPES = `type FleetIsAny<T> = 0 extends 1 & T ? true : false;
+type FleetSimplify<T> = { [TKey in keyof T]: T[TKey] } & {};
+type FleetSerializeObject<T extends object> = {
+\t[TKey in keyof T as FleetIsAny<T[TKey]> extends true
+\t\t? TKey
+\t\t: [T[TKey]] extends [undefined]
+\t\t\t? never
+\t\t\t: T[TKey] extends (...args: never[]) => unknown
+\t\t\t\t? never
+\t\t\t\t: TKey]: FleetSerializeOutput<T[TKey]>;
+};
+type FleetSerializeOutput<T> = FleetIsAny<T> extends true
+\t? T
+\t: T extends (...args: never[]) => unknown
+\t\t? never
+\t\t: T extends Date
+\t\t\t? string
+\t\t\t: T extends readonly (infer TItem)[]
+\t\t\t\t? FleetSerializeOutput<TItem>[]
+\t\t\t\t: T extends { toJSON(): infer TJSON }
+\t\t\t\t\t? TJSON extends object
+\t\t\t\t\t\t? FleetSimplify<
+\t\t\t\t\t\t\t\tOmit<FleetSerializeObject<Omit<T, "toJSON">>, keyof TJSON> &
+\t\t\t\t\t\t\t\t\tFleetSerializeOutput<TJSON>
+\t\t\t\t\t\t\t>
+\t\t\t\t\t\t: FleetSerializeOutput<TJSON>
+\t\t\t\t\t: T extends object
+\t\t\t\t\t\t? FleetSerializeObject<T>
+\t\t\t\t\t\t: T;
+type FleetProcedureOutput<T> = { toJSON(): FleetSerializeOutput<T> };`;
+
 const command = process.argv[2];
 
 if (!command || command === "--help" || command === "-h") {
@@ -51,184 +81,224 @@ async function generateTypes() {
 	const apiRoot = path.resolve(callerRoot, fleetApiPath);
 	const outputPath = path.resolve(callerRoot, fleetApiTypesPath);
 	const routerSourcePath = path.join(apiRoot, "src/routers/trpc/index.ts");
-	const prismaTypesPath = path.join(apiRoot, "prisma/types.d.ts");
+	const apiTsconfigPath = path.join(apiRoot, "tsconfig.json");
 	const executableExtension = process.platform === "win32" ? ".cmd" : "";
-	const apiTscPath = path.join(apiRoot, `node_modules/.bin/tsc${executableExtension}`);
 	const callerBiomePath = path.join(callerRoot, `node_modules/.bin/biome${executableExtension}`);
 	const packageBiomePath = path.join(packageRoot, `node_modules/.bin/biome${executableExtension}`);
 	const biomePath = existsSync(callerBiomePath) ? callerBiomePath : packageBiomePath;
-	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");
+	const configResult = ts.readConfigFile(apiTsconfigPath, ts.sys.readFile);
 
-	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}.`);
+	if (configResult.error) {
+		throw new Error(formatTypeScriptDiagnostics(ts, [configResult.error], apiRoot));
+	}
+
+	const parsedConfig = ts.parseJsonConfigFileContent(
+		configResult.config,
+		ts.sys,
+		apiRoot,
+		{
+			declaration: true,
+			declarationMap: false,
+			emitDeclarationOnly: true,
+			incremental: false,
+			noEmit: false,
+			noEmitOnError: false,
+		},
+		apiTsconfigPath,
+	);
+
+	if (parsedConfig.errors.length > 0) {
+		throw new Error(formatTypeScriptDiagnostics(ts, parsedConfig.errors, apiRoot));
+	}
+
+	const program = ts.createProgram({
+		options: parsedConfig.options,
+		rootNames: parsedConfig.fileNames,
+	});
+	const routerSource = program.getSourceFile(routerSourcePath);
+
+	if (!routerSource) {
+		throw new Error(`Unable to load AppRouter source at ${routerSourcePath}.`);
+	}
+
+	const sourceDiagnostics = [
+		...program.getSyntacticDiagnostics(routerSource),
+		...program.getSemanticDiagnostics(routerSource),
+	].filter(diagnostic => diagnostic.category === ts.DiagnosticCategory.Error);
+
+	if (sourceDiagnostics.length > 0) {
+		throw new Error(formatTypeScriptDiagnostics(ts, sourceDiagnostics, apiRoot));
+	}
+
+	let emittedDeclaration;
+	const emitResult = program.emit(
+		routerSource,
+		(fileName, content) => {
+			if (fileName.endsWith(".d.ts")) emittedDeclaration = content;
+		},
+		undefined,
+		true,
+	);
+	const emitDiagnostics = emitResult.diagnostics.filter(
+		diagnostic => diagnostic.category === ts.DiagnosticCategory.Error,
+	);
+
+	if (emitDiagnostics.length > 0) {
+		throw new Error(formatTypeScriptDiagnostics(ts, emitDiagnostics, apiRoot));
+	}
+	if (!emittedDeclaration) {
+		throw new Error(`TypeScript did not emit a declaration for ${routerSourcePath}.`);
+	}
+
+	const emittedPath = routerSourcePath.replace(/\.ts$/, ".d.ts");
+	const sourceFile = ts.createSourceFile(emittedPath, emittedDeclaration, ts.ScriptTarget.Latest, true);
+	const sanitizedSourceFile = sanitizeBackendTypes(ts, sourceFile);
+	const transformedSourceFile = transformProcedureOutputs(ts, sanitizedSourceFile);
+	const statements = transformedSourceFile.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, transformedSourceFile))
+		.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${SERIALIZED_OUTPUT_TYPES}\n${appRouterDeclaration}\n`,
+	);
+
+	if (existsSync(biomePath)) {
+		const biomeResult = spawnSync(biomePath, ["format", "--write", outputPath], {
+			cwd: callerRoot,
+			stdio: "inherit",
+		});
+		if (biomeResult.error) {
+			throw biomeResult.error;
 		}
-		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,
-			`interface Permission {
-	name: string;
-}
+		if (biomeResult.status !== 0) {
+			throw new Error(`Biome formatting failed with exit code ${biomeResult.status}.`);
+		}
+	}
 
-interface AuthenticatedUser {
-	id: number;
-	dailyHours: number | null;
-	permissionGroups: { permissions: Permission[] }[];
-	permissions: Permission[];
-	team: { folderKey: string | null; id: number } | null;
+	console.log(`Generated ${path.relative(callerRoot, outputPath)} from ${routerSourcePath}`);
 }
 
-interface DecodedToken {
-	permissions: string[];
-	type: "USER" | "EMPLOYEE";
-	user: { id: string; role: string };
-}
+function transformProcedureOutputs(ts, sourceFile) {
+	const procedureTypes = new Set(["TRPCMutationProcedure", "TRPCQueryProcedure", "TRPCSubscriptionProcedure"]);
+	const transformation = ts.transform(sourceFile, [
+		context => {
+			const visit = node => {
+				if (
+					ts.isImportTypeNode(node) &&
+					ts.isIdentifier(node.qualifier) &&
+					procedureTypes.has(node.qualifier.text) &&
+					node.typeArguments?.length
+				) {
+					const [procedureDefinition, ...remainingTypeArguments] = node.typeArguments;
 
-interface CacheOptions {
-	tags?: string[];
-	ttl?: number;
-}
+					if (ts.isTypeLiteralNode(procedureDefinition)) {
+						const members = procedureDefinition.members.map(member => {
+							if (
+								ts.isPropertySignature(member) &&
+								member.type &&
+								ts.isIdentifier(member.name) &&
+								member.name.text === "output"
+							) {
+								return ts.factory.updatePropertySignature(
+									member,
+									member.modifiers,
+									member.name,
+									member.questionToken,
+									ts.factory.createTypeReferenceNode("FleetProcedureOutput", [member.type]),
+								);
+							}
 
-export declare class ServiceProvider {
-	static getAuthenticationService(): {
-		decodeToken(token: string): DecodedToken;
-		login(email: string, password: string, tokenExpiry?: string): Promise<string>;
-	};
-	static getCachingService(): {
-		fnc<T>(key: string, fn: Promise<T> | (() => Promise<T>), options?: CacheOptions): Promise<T>;
-	};
-	static getDatabaseService(): {
-		getPrisma(): {
-			user: {
-				findFirst(args: unknown): Promise<AuthenticatedUser | null>;
-			};
-			userAttendance: {
-				findFirst(args: unknown): Promise<{ id: number } | null>;
+							return member;
+						});
+						const updatedDefinition = ts.factory.updateTypeLiteralNode(procedureDefinition, members);
+
+						return ts.factory.updateImportTypeNode(
+							node,
+							node.argument,
+							node.attributes,
+							node.qualifier,
+							[updatedDefinition, ...remainingTypeArguments],
+							node.isTypeOf,
+						);
+					}
+				}
+
+				return ts.visitEachChild(node, visit, context);
 			};
-		};
-	};
-	static getEncryptionService(): {
-		decodeId(encodedId: string, prefix: string): number;
-	};
+
+			return rootNode => ts.visitNode(rootNode, visit);
+		},
+	]);
+	const transformedSourceFile = transformation.transformed[0];
+
+	transformation.dispose();
+
+	return transformedSourceFile;
 }
-`,
-		);
-		await writeFile(
-			declarationTsconfigPath,
-			`${JSON.stringify(
-				{
-					compilerOptions: {
-						declaration: true,
-						declarationMap: false,
-						emitDeclarationOnly: true,
-						incremental: true,
-						noEmit: false,
-						outDir: declarationOutputDirectory,
-						paths: {
-							"@/*": [path.join(apiRoot, "src/*")],
-							"@/providers": [serviceProviderShimPath],
-							"@/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}.`);
-		}
+function sanitizeBackendTypes(ts, sourceFile) {
+	const transformation = ts.transform(sourceFile, [
+		context => {
+			const visit = node => {
+				if (ts.isTypeReferenceNode(node)) {
+					let typeName = node.typeName;
 
-		const emittedPath = path
-			.join(declarationOutputDirectory, path.relative(path.join(apiRoot, "src"), routerSourcePath))
-			.replace(/\.ts$/, ".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.");
-		}
+					while (ts.isQualifiedName(typeName)) typeName = typeName.left;
 
-		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}.`);
-			}
-		}
+					if (ts.isIdentifier(typeName) && typeName.text === "PrismaJson") {
+						return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+					}
+				}
 
-		console.log(`Generated ${path.relative(callerRoot, outputPath)} from ${routerSourcePath}`);
-	} finally {
-		await rm(temporaryDirectory, { force: true, recursive: true });
-	}
+				if (
+					ts.isImportTypeNode(node) &&
+					ts.isLiteralTypeNode(node.argument) &&
+					ts.isStringLiteral(node.argument.literal) &&
+					node.argument.literal.text.startsWith("@/")
+				) {
+					return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+				}
+
+				return ts.visitEachChild(node, visit, context);
+			};
+
+			return rootNode => ts.visitNode(rootNode, visit);
+		},
+	]);
+	const transformedSourceFile = transformation.transformed[0];
+
+	transformation.dispose();
+
+	return transformedSourceFile;
+}
+
+function formatTypeScriptDiagnostics(ts, diagnostics, currentDirectory) {
+	return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
+		getCanonicalFileName: fileName => fileName,
+		getCurrentDirectory: () => currentDirectory,
+		getNewLine: () => "\n",
+	});
 }
 
 function printUsage() {

package/package.json

@@ -57,5 +57,5 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "types": "dist/types/index.d.ts",
-  "version": "1.0.103"
+  "version": "1.0.105"
 }

package/dist/types/trpc.d.ts

@@ -1,54 +0,0 @@
-// Generated by `npx @automateinc/fleet-types generate`. Do not edit manually.
-export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<
-	{
-		ctx: {
-			client: "FLEET_MOBILE" | "FLEET_MOBILE_USER" | "FLEET_WEB" | undefined;
-			regionId: string | undefined;
-			request: import("express").Request<
-				import("express-serve-static-core").ParamsDictionary,
-				any,
-				any,
-				import("qs").ParsedQs,
-				Record<string, any>
-			>;
-			token: string | undefined;
-		};
-		meta: object;
-		errorShape: import("@trpc/server").TRPCDefaultErrorShape;
-		transformer: false;
-	},
-	import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-		auth: import("@trpc/server").TRPCBuiltRouter<
-			{
-				ctx: {
-					client: "FLEET_MOBILE" | "FLEET_MOBILE_USER" | "FLEET_WEB" | undefined;
-					regionId: string | undefined;
-					request: import("express").Request<
-						import("express-serve-static-core").ParamsDictionary,
-						any,
-						any,
-						import("qs").ParsedQs,
-						Record<string, any>
-					>;
-					token: string | undefined;
-				};
-				meta: object;
-				errorShape: import("@trpc/server").TRPCDefaultErrorShape;
-				transformer: false;
-			},
-			import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-				login: import("@trpc/server").TRPCMutationProcedure<{
-					input: {
-						email: string;
-						password: string;
-					};
-					output: {
-						token: string;
-					};
-					meta: object;
-				}>;
-			}>
-		>;
-	}>
->;
-export type AppRouter = typeof appRouter;