@beignet/cli 0.0.48 → 0.0.50

package/dist/make.js

@@ -2,6 +2,8 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
+import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
+import { listProjectFiles } from "./analysis/workspace.js";
 import { clientFormsPath, clientIndexPath, loadBeignetConfig, resolveConfig, } from "./config.js";
 import { assertNextFramework } from "./framework.js";
 import { adapterFilePath, addNamedImport, addNamedTypeImport, aliasModule, appendDeferredPortKey, appendPickStringLiteralMember, applyPortProviderWiring, assertAdapterApp, assertFeatureArtifactApp, assertFeatureUiApp, assertGeneratedIdentifiers, assertPersistenceArtifactApp, assertPolicyApp, assertPortApp, assertServerRuntimeApp, assertStandardApp, assertTestApp, assertUseCaseApp, beignetDependencyVersion, constantCase, createListenersRegistrySource, defineUploadsInitializerInfo, detectResourceDatabase, detectResourcePersistence, drizzleDialects, drizzleRepositoriesPath, drizzleResourceRepositoryFilePath, drizzleSchemaIndexPath, eventBusPortWiring, eventFilePath, factoryFilePath, featureArtifactDir, featureArtifactIndexFile, featureArtifactNames, featureResourceNames, featureUiClientQueriesFilePath, featureUiComponentFilePath, featureUiIndexFilePath, featureUiNames, fileExists, hasTopLevelObjectProperty, identifierNames, infrastructureDir, insertTypeProperty, jobFilePath, listenerFilePath, listenersFilePath, mergeMakeResultInto, mergeMakeResults, missingCapabilityBuilderFiles, notificationFilePath, notificationPortWirings, planGeneratedFile, planGeneratedFiles, portFilePath, portNames, providersFilePath, readOptionalFile, relativeModule, resourceContractFilePath, resourceFeatureDir, resourceNames, resourcePortFilePath, resourceSharedErrorsPath, scheduleFilePath, seedEntrypointPath, seedFilePath, seedNames, singularize, storagePortWiring, tanstackReactQueryDependencyVersion, taskFilePath, typeBodySource, uniqueStrings, updateDrizzleRepositories, updateDrizzleSchemaIndex, updateFeatureArtifactIndex, updateInfrastructureAdapterWiring, updateInfrastructureDeferredPorts, updateInfrastructureGatePolicies, updateInfrastructurePortStub, updateInfrastructurePorts, updateListenersRegistrySource, updateOpenApiRoute, updatePackageDependencies, updatePackageJson, updatePackageScripts, updatePortIndex, updatePortsIndex, updateSeedEntrypoint, updateServerRoutes, updateServerTransactionPorts, updateSharedErrors, uploadFilePath, useCaseFeatureDir, useCaseFilePath, usesFeatureOwnedPolicies, usesFeatureOwnedTests, wireListenersProviderSource, wirePortProviders, writeGeneratedFile, writePlannedGeneratedFile, } from "./make/shared.js";
@@ -552,6 +554,7 @@ export async function makeJob(options) {
     await assertFeatureArtifactApp(targetDir, config, "job");
     await assertServerRuntimeApp(targetDir, config, "job");
     await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+    const jobDispatcherPlan = await planInlineJobDispatcherWiring(targetDir, config);
     const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
         force: Boolean(options.force),
     });
@@ -580,6 +583,9 @@ export async function makeJob(options) {
     await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
         dryRun: Boolean(options.dryRun),
     });
+    await applyInlineJobDispatcherWiring(result, targetDir, jobDispatcherPlan, {
+        dryRun: Boolean(options.dryRun),
+    });
     await applyOutboxPortWiring(result, targetDir, config, {
         dryRun: Boolean(options.dryRun),
     });
@@ -588,6 +594,123 @@ export async function makeJob(options) {
     });
     return result;
 }
+async function planInlineJobDispatcherWiring(targetDir, config) {
+    const portsFile = config.paths.ports;
+    const portWiringFile = config.paths.portWiring;
+    const providersFile = providersFilePath(config);
+    const ports = await readFile(path.join(targetDir, portsFile), "utf8");
+    const portWiring = await readFile(path.join(targetDir, portWiringFile), "utf8");
+    const analysis = await analyzePortWiringFiles({
+        targetDir,
+        files: await listProjectFiles(targetDir),
+        config,
+    });
+    const declaresJobs = analysis.declared.has("jobs");
+    const wiresJobs = analysis.bound.has("jobs") || analysis.deferred.has("jobs");
+    if (declaresJobs && wiresJobs) {
+        return { changes: [] };
+    }
+    if (!declaresJobs && analysis.declarationIndeterminate) {
+        throw new Error(`Could not prove whether AppPorts in ${portsFile} declares the jobs port. Preserve the app's custom port type and add jobs: JobDispatcherPort manually before running make job.`);
+    }
+    if (!wiresJobs && analysis.indeterminate) {
+        throw new Error(`Could not prove how the jobs port is wired in ${portWiringFile}. Preserve the app's custom dispatcher by binding or deferring "jobs" in a statically inspectable definePorts(...) object before running make job.`);
+    }
+    let nextPorts = ports;
+    if (!declaresJobs && !analysis.appPortsInferredFromWiring) {
+        nextPorts = addNamedTypeImport(nextPorts, "JobDispatcherPort", "@beignet/core/ports");
+        nextPorts = insertTypeProperty(nextPorts, "AppPorts", "jobs: JobDispatcherPort;", `Could not find AppPorts in ${portsFile}. Add jobs: JobDispatcherPort manually and wire a dispatcher, or restore the generated ports file before running make job.`);
+    }
+    if (wiresJobs) {
+        return {
+            changes: ports === nextPorts
+                ? []
+                : [{ path: portsFile, before: ports, after: nextPorts }],
+        };
+    }
+    const nextPortWiring = appendDeferredPortKey(portWiring, "jobs");
+    if (nextPortWiring === portWiring) {
+        throw new Error(`Could not find the deferred port list in ${portWiringFile}. Add "jobs" manually and wire a dispatcher, or restore the generated port wiring file before running make job.`);
+    }
+    const providersPath = path.join(targetDir, providersFile);
+    const providers = await readOptionalFile(providersPath);
+    if (providers === undefined) {
+        throw new Error(`Could not find ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`);
+    }
+    let nextProviders = addNamedImport(providers, "createInlineJobDispatcher", "@beignet/core/jobs");
+    nextProviders = addNamedImport(nextProviders, "createProvider", "@beignet/core/providers");
+    nextProviders = addNamedTypeImport(nextProviders, "AppContext", aliasModule(config.paths.appContext));
+    nextProviders = addNamedTypeImport(nextProviders, "AppPorts", aliasModule(config.paths.ports));
+    nextProviders = addNamedTypeImport(nextProviders, "AppServiceContextInput", aliasModule(path.join(path.dirname(config.paths.server), "context.ts")));
+    const providerName = "inlineJobsProvider";
+    const generatedProviderMarker = "// beignet:generated-inline-jobs-provider";
+    const providersSourceFile = ts.createSourceFile(providersFile, nextProviders, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const providerDeclaration = providersSourceFile.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((statement) => [...statement.declarationList.declarations])
+        .find((declaration) => ts.isIdentifier(declaration.name) &&
+        declaration.name.text === providerName);
+    const providerDeclarationExists = providerDeclaration !== undefined;
+    const providerIsGenerated = providerDeclaration
+        ? nextProviders
+            .slice(0, providerDeclaration.getStart(providersSourceFile))
+            .trimEnd()
+            .endsWith(generatedProviderMarker)
+        : false;
+    if (providerDeclarationExists && !providerIsGenerated) {
+        throw new Error(`Could not install the generated inline jobs dispatcher because ${providerName} already exists in ${providersFile}. Rename the app-owned declaration or wire its jobs port explicitly before running make job.`);
+    }
+    if (!providerDeclarationExists) {
+        const definition = `// beignet:generated-inline-jobs-provider
+const ${providerName} = createProvider<
+	{},
+	AppContext,
+	AppServiceContextInput
+>()({
+	name: "inline-jobs",
+	setup({ createServiceContext }): { ports: Pick<AppPorts, "jobs"> } {
+		return {
+			ports: {
+				jobs: createInlineJobDispatcher<AppContext>({
+					ctx: () => createServiceContext(undefined),
+				}),
+			},
+		};
+	},
+});
+`;
+        const inserted = nextProviders.replace(/\nexport const providers = \[/, `\n${definition}\nexport const providers = [`);
+        if (inserted === nextProviders) {
+            throw new Error(`Could not find the exported providers array in ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`);
+        }
+        nextProviders = inserted;
+    }
+    const appended = appendToNamedArray(nextProviders, "providers", providerName);
+    if (appended.kind === "missing") {
+        throw new Error(`Could not find the exported providers array in ${providersFile}. Register ${providerName} manually, or restore the generated providers file before running make job.`);
+    }
+    if (appended.kind === "updated")
+        nextProviders = appended.source;
+    return {
+        changes: [
+            { path: portsFile, before: ports, after: nextPorts },
+            { path: portWiringFile, before: portWiring, after: nextPortWiring },
+            { path: providersFile, before: providers, after: nextProviders },
+        ].filter((change) => change.before !== change.after),
+    };
+}
+async function applyInlineJobDispatcherWiring(result, targetDir, plan, options) {
+    for (const change of plan.changes) {
+        if (!options.dryRun) {
+            await writeFile(path.join(targetDir, change.path), change.after);
+        }
+        if (!result.updatedFiles.includes(change.path)) {
+            result.updatedFiles.push(change.path);
+        }
+        if (!result.files.includes(change.path))
+            result.files.push(change.path);
+    }
+}
 export async function makeTask(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = taskNames(options.name);
@@ -2552,8 +2675,8 @@ export function decode${names.singularPascal}Cursor(cursor: string): ${names.sin
 
 export const List${names.pluralPascal}InputSchema = z
 	.object({
-		limit: z.coerce.number().int().min(1).max(100).default(20),
-		cursor: z.string().nullable().default(null),
+		limit: z.number().int().min(1).max(100).default(20),
+		cursor: z.string().optional().transform((value) => value ?? null),
 		name: z.string().trim().min(1).max(120).optional(),
 		sortBy: ${names.singularPascal}SortBySchema.default("createdAt"),
 		sortDirection: ${names.singularPascal}SortDirectionSchema.default("desc"),
@@ -3316,7 +3439,7 @@ ${createMethod}${resourceMethods}
 `;
 }
 function contractFile(names, config, mode, options) {
-    return `import { defineContractGroup } from "@beignet/core/contracts";
+    return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 ${mode === "resource" ? `import { errors } from "${aliasModule(resourceSharedErrorsPath(config))}";\n` : ""}import {
 	Create${names.singularPascal}InputSchema,
@@ -3339,7 +3462,16 @@ const ${names.pluralCamel} = defineContractGroup()
 
 export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
-	.query(List${names.pluralPascal}InputSchema)
+	.query(
+		List${names.pluralPascal}InputSchema,
+		defineQueryTransport({
+			limit: query.integer(),
+			cursor: query.string(),
+			name: query.string(),
+			sortBy: query.string(),
+			sortDirection: query.string(),
+		}),
+	)
 	.responses({
 		200: List${names.pluralPascal}OutputSchema,
 	});
@@ -3381,7 +3513,7 @@ ${options.authorization ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization:
 `;
 }
 function standaloneContractFile(names) {
-    return `import { defineContractGroup } from "@beignet/core/contracts";
+    return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 
 const ErrorResponseSchema = z.object({
@@ -3405,8 +3537,12 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
 	.query(
 		z.object({
-			limit: z.coerce.number().int().min(1).max(100).default(20),
-			offset: z.coerce.number().int().min(0).default(0),
+			limit: z.number().int().min(1).max(100).default(20),
+			offset: z.number().int().min(0).default(0),
+		}),
+		defineQueryTransport({
+			limit: query.integer(),
+			offset: query.integer(),
 		}),
 	)
 	.responses({
@@ -4372,7 +4508,7 @@ ${options.authorization ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
 		);
 		const secondPage = await tester.run(
 			list${names.pluralPascal}UseCase,
-			{ limit: 2, cursor: firstPage.page.nextCursor },
+			{ limit: 2, cursor: firstPage.page.nextCursor! },
 			{ ctx },
 		);
 		const nameAscendingPage = await tester.run(