@tailor-platform/sdk 0.11.3 → 0.12.1

package/dist/{token-BJq9rpG5.mjs → list-6vWylIIR.mjs}

@@ -901,7 +901,7 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig) {
 //#endregion
 //#region src/cli/bundler/workflow/ast-transformer.ts
 /**
-* Check if a module source is from @tailor-platform/sdk (including subpaths)
+* Check if a module source is from \@tailor-platform/sdk (including subpaths)
 */
 function isTailorSdkSource(source) {
 	return /^@tailor-platform\/sdk(\/|$)/.test(source);
@@ -932,7 +932,7 @@ function unwrapAwait(node) {
 	return node;
 }
 /**
-* Collect all import bindings for createWorkflowJob from @tailor-platform/sdk
+* Collect all import bindings for createWorkflowJob from \@tailor-platform/sdk
 * Returns a Set of local names that refer to createWorkflowJob
 */
 function collectCreateWorkflowJobBindings(program) {
@@ -1033,7 +1033,7 @@ function findProperty(properties, name) {
 	return null;
 }
 /**
-* Find all workflow jobs by detecting createWorkflowJob calls from @tailor-platform/sdk
+* Find all workflow jobs by detecting createWorkflowJob calls from \@tailor-platform/sdk
 */
 function findAllJobs(program, _sourceText) {
 	const jobs = [];
@@ -1457,7 +1457,7 @@ var EnumConstantsGenerator = class {
 	aggregate(args) {
 		const files = [];
 		const allEnums = [];
-		for (const input of args.inputs) for (const nsResult of input.tailordb) if (nsResult.types && nsResult.types.enums.length > 0) allEnums.push(...nsResult.types.enums);
+		for (const nsResult of args.input.tailordb) if (nsResult.types && nsResult.types.enums.length > 0) allEnums.push(...nsResult.types.enums);
 		if (allEnums.length > 0) {
 			const content = EnumProcessor.generateUnifiedEnumConstants(allEnums);
 			files.push({
@@ -1597,7 +1597,7 @@ var FileUtilsGenerator = class {
 	aggregate(args) {
 		const files = [];
 		const allNamespaceData = [];
-		for (const input of args.inputs) for (const nsResult of input.tailordb) if (nsResult.types) try {
+		for (const nsResult of args.input.tailordb) if (nsResult.types) try {
 			const parsed = JSON.parse(nsResult.types);
 			if (parsed.namespace && parsed.types) allNamespaceData.push(parsed);
 		} catch {}
@@ -1838,7 +1838,7 @@ var KyselyGenerator = class {
 	aggregate(args) {
 		const files = [];
 		const allNamespaceData = [];
-		for (const input of args.inputs) for (const nsResult of input.tailordb) if (nsResult.types && nsResult.types.types.length > 0) allNamespaceData.push(nsResult.types);
+		for (const nsResult of args.input.tailordb) if (nsResult.types && nsResult.types.types.length > 0) allNamespaceData.push(nsResult.types);
 		if (allNamespaceData.length > 0) {
 			const content = TypeProcessor.generateUnifiedTypes(allNamespaceData);
 			files.push({
@@ -1879,6 +1879,74 @@ function processGqlIngest(type) {
 	};
 }
 
+//#endregion
+//#region src/cli/generator/builtin/seed/idp-user-processor.ts
+/**
+* Processes auth configuration to generate IdP user seed metadata
+*/
+function processIdpUser(auth) {
+	if (auth.idProvider?.kind !== "BuiltInIdP" || !auth.userProfile) return;
+	const { typeName, usernameField } = auth.userProfile;
+	return {
+		name: "_User",
+		dependencies: [typeName],
+		mapping: {
+			dataFile: "data/_User.jsonl",
+			dataFormat: "jsonl",
+			graphqlFile: "graphql/_User.graphql",
+			mapping: { input: "$" }
+		},
+		graphql: `mutation CreateUser($input: _CreateUserInput!) {
+  _createUser(input: $input) {
+    id
+  }
+}
+`,
+		schema: {
+			usernameField,
+			userTypeName: typeName
+		}
+	};
+}
+/**
+* Generates the schema file content for IdP users with foreign key
+*/
+function generateIdpUserSchemaFile(usernameField, userTypeName) {
+	return ml`
+    import { t } from "@tailor-platform/sdk";
+    import { createStandardSchema } from "@tailor-platform/sdk/test";
+    import { defineSchema } from "@toiroakr/lines-db";
+
+    const schemaType = t.object({
+      name: t.string(),
+      password: t.string(),
+    });
+
+    // Simple identity hook for _User (no TailorDB backing type)
+    const hook = <T>(data: unknown) => data as T;
+
+    export const schema = defineSchema(
+      createStandardSchema(schemaType, hook),
+      {
+        primaryKey: "name",
+        indexes: [
+          { name: "_user_name_unique_idx", columns: ["name"], unique: true },
+        ],
+        foreignKeys: [
+          {
+            column: "name",
+            references: {
+              table: "${userTypeName}",
+              column: "${usernameField}",
+            },
+          },
+        ],
+      }
+    );
+
+    `;
+}
+
 //#endregion
 //#region src/cli/generator/builtin/seed/lines-db-processor.ts
 /**
@@ -1976,15 +2044,37 @@ const SeedGeneratorID = "@tailor-platform/seed";
 * Combines GraphQL Ingest and lines-db schema generation.
 */
 /**
-* Generates the exec.sh script content
+* Generates the exec.mjs script content (Node.js executable)
 */
 function generateExecScript(machineUserName, configDir) {
-	return `#!/usr/bin/env bash
+	return ml`
+    import { execSync } from "node:child_process";
+    import { show, machineUserToken } from "@tailor-platform/sdk/cli";
 
-ENDPOINT="$(pnpm exec tailor-sdk show -f json | jq -r '.url' || true)/query"
-HEADER="{ \\"Authorization\\": \\"Bearer $(pnpm exec tailor-sdk machineuser token "${machineUserName}" -f json | jq -r '.access_token' || true)\\" }"
-gql-ingest -c ${configDir} -e "\${ENDPOINT}" --headers "\${HEADER}"
-`;
+    console.log("Starting seed data generation...");
+
+    const appInfo = await show();
+    const endpoint = \`\${appInfo.url}/query\`;
+
+    const tokenInfo = await machineUserToken({ name: "${machineUserName}" });
+    const headers = JSON.stringify({ Authorization: \`Bearer \${tokenInfo.accessToken}\` });
+
+    // Build command with platform-specific quoting
+    const headersArg = process.platform === "win32"
+      ? \`"\${headers.replace(/"/g, '\\\\"')}"\`  // Windows: escape " as \\"
+      : \`'\${headers}'\`;                        // Unix: use single quotes
+
+    const cmd = \`npx gql-ingest -c ${configDir} -e "\${endpoint}" --headers \${headersArg}\`;
+    console.log("Running:", cmd);
+
+    try {
+      execSync(cmd, { stdio: "inherit" });
+    } catch (error) {
+      console.error("Seed failed with exit code:", error.status);
+      process.exit(error.status ?? 1);
+    }
+
+    `;
 }
 function createSeedGenerator(options) {
 	return {
@@ -2001,10 +2091,10 @@ function createSeedGenerator(options) {
 		processTailorDBNamespace: ({ types }) => types,
 		processExecutor: (_executor) => void 0,
 		processResolver: (_args) => void 0,
-		aggregate: ({ inputs }) => {
+		aggregate: ({ input }) => {
 			const entityDependencies = {};
 			const files = [];
-			for (const input of inputs) for (const nsResult of input.tailordb) {
+			for (const nsResult of input.tailordb) {
 				if (!nsResult.types) continue;
 				const outputBaseDir = options.distPath;
 				if (!(outputBaseDir in entityDependencies)) entityDependencies[outputBaseDir] = {};
@@ -2031,6 +2121,31 @@ function createSeedGenerator(options) {
 					});
 				}
 			}
+			if (input.auth) {
+				const idpUser = processIdpUser(input.auth);
+				if (idpUser) {
+					const outputBaseDir = options.distPath;
+					if (!(outputBaseDir in entityDependencies)) entityDependencies[outputBaseDir] = {};
+					entityDependencies[outputBaseDir][idpUser.name] = idpUser.dependencies;
+					files.push({
+						path: path.join(outputBaseDir, idpUser.mapping.graphqlFile),
+						content: idpUser.graphql
+					});
+					files.push({
+						path: path.join(outputBaseDir, "mappings", `${idpUser.name}.json`),
+						content: JSON.stringify(idpUser.mapping, null, 2) + "\n"
+					});
+					files.push({
+						path: path.join(outputBaseDir, idpUser.mapping.dataFile),
+						content: "",
+						skipIfExists: true
+					});
+					files.push({
+						path: path.join(outputBaseDir, "data", `${idpUser.name}.schema.ts`),
+						content: generateIdpUserSchemaFile(idpUser.schema.usernameField, idpUser.schema.userTypeName)
+					});
+				}
+			}
 			for (const [outputDir, dependencies] of Object.entries(entityDependencies)) {
 				files.push({
 					path: path.join(outputDir, "config.yaml"),
@@ -2039,9 +2154,8 @@ function createSeedGenerator(options) {
 `
 				});
 				if (options.machineUserName) files.push({
-					path: path.join(outputDir, "exec.sh"),
-					content: generateExecScript(options.machineUserName, path.basename(outputDir)),
-					executable: true
+					path: path.join(outputDir, "exec.mjs"),
+					content: generateExecScript(options.machineUserName, path.basename(outputDir))
 				});
 			}
 			return { files };
@@ -2100,32 +2214,30 @@ function extractAttributesFromConfig(config) {
 	return collectAttributesFromConfig(config);
 }
 function generateTypeDefinition(attributeMap, attributeList, env) {
-	const mapFields = attributeMap ? Object.entries(attributeMap).map(([key, value]) => `      ${key}: ${value};`).join("\n") : "";
+	const mapFields = attributeMap ? Object.entries(attributeMap).map(([key, value]) => `    ${key}: ${value};`).join("\n") : "";
 	const mapBody = !attributeMap || Object.keys(attributeMap).length === 0 ? "{}" : `{
 ${mapFields}
-    }`;
+  }`;
 	const listBody = `{
-      __tuple?: ${attributeList ? `[${attributeList.map(() => "string").join(", ")}]` : "[]"};
-    }`;
+    __tuple?: ${attributeList ? `[${attributeList.map(() => "string").join(", ")}]` : "[]"};
+  }`;
 	const envFields = env ? Object.entries(env).map(([key, value]) => {
 		const valueType = typeof value === "string" ? `"${value}"` : String(value);
-		return `      ${key}: ${valueType};`;
+		return `    ${key}: ${valueType};`;
 	}).join("\n") : "";
 	const envBody = !env || Object.keys(env).length === 0 ? "{}" : `{
 ${envFields}
-    }`;
+  }`;
 	return ml`
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 // This file is auto-generated by @tailor-platform/sdk
 // Do not edit this file manually
 // Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
 
-declare global {
-  namespace TailorSDK {
-    interface AttributeMap ${mapBody}
-    interface AttributeList ${listBody}
-    interface Env ${envBody}
-  }
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap ${mapBody}
+  interface AttributeList ${listBody}
+  interface Env ${envBody}
 }
 
 export {};
@@ -2165,8 +2277,8 @@ function resolveTypeDefinitionPath(configPath) {
 	if (typePath) return path.resolve(process.cwd(), typePath);
 	const configDir = path.dirname(path.resolve(configPath));
 	const packageDir = resolvePackageDirectory(configDir);
-	if (!packageDir) return path.join(configDir, "node_modules", "@tailor-platform", "sdk", "dist", "plugin-generated.d.ts");
-	return path.join(packageDir, "dist", "plugin-generated.d.ts");
+	if (!packageDir) return path.join(configDir, "node_modules", "@tailor-platform", "sdk", "dist", "user-defined.d.ts");
+	return path.join(packageDir, "dist", "user-defined.d.ts");
 }
 async function generateUserTypes(config, configPath) {
 	try {
@@ -6271,8 +6383,11 @@ var DependencyWatcher = class {
 //#region src/cli/generator/index.ts
 var GenerationManager = class {
 	application;
-	applications = {};
-	executors = {};
+	services = {
+		tailordb: {},
+		resolver: {},
+		executor: {}
+	};
 	baseDir;
 	constructor(config, generators = [], configPath) {
 		this.generators = generators;
@@ -6285,45 +6400,39 @@ var GenerationManager = class {
 		console.log("");
 		console.log("Generation for application:", styleText("cyanBright", this.application.config.name));
 		console.log("");
-		for (const app of this.application.applications) {
-			const appNamespace = app.name;
-			this.applications[appNamespace] = {
-				tailordbNamespaces: {},
-				resolverNamespaces: {}
-			};
-			for (const db of app.tailorDBServices) {
-				const namespace = db.namespace;
-				try {
-					await db.loadTypes();
-					this.applications[appNamespace].tailordbNamespaces[namespace] = {
-						types: db.getTypes(),
-						sourceInfo: db.getTypeSourceInfo()
-					};
-				} catch (error) {
-					console.error(styleText("red", "Error loading types for TailorDB service"), styleText("redBright", namespace));
-					console.error(error);
-					if (!watch) throw error;
-				}
+		const app = this.application;
+		for (const db of app.tailorDBServices) {
+			const namespace = db.namespace;
+			try {
+				await db.loadTypes();
+				this.services.tailordb[namespace] = {
+					types: db.getTypes(),
+					sourceInfo: db.getTypeSourceInfo()
+				};
+			} catch (error) {
+				console.error(styleText("red", "Error loading types for TailorDB service"), styleText("redBright", namespace));
+				console.error(error);
+				if (!watch) throw error;
 			}
-			for (const resolverService of app.resolverServices) {
-				const namespace = resolverService.namespace;
-				try {
-					await resolverService.loadResolvers();
-					this.applications[appNamespace].resolverNamespaces[namespace] = {};
-					Object.entries(resolverService.getResolvers()).forEach(([_, resolver]) => {
-						this.applications[appNamespace].resolverNamespaces[namespace][resolver.name] = resolver;
-					});
-				} catch (error) {
-					console.error(styleText("red", "Error loading resolvers for Resolver service"), styleText("redBright", namespace));
-					console.error(error);
-					if (!watch) throw error;
-				}
+		}
+		for (const resolverService of app.resolverServices) {
+			const namespace = resolverService.namespace;
+			try {
+				await resolverService.loadResolvers();
+				this.services.resolver[namespace] = {};
+				Object.entries(resolverService.getResolvers()).forEach(([_, resolver]) => {
+					this.services.resolver[namespace][resolver.name] = resolver;
+				});
+			} catch (error) {
+				console.error(styleText("red", "Error loading resolvers for Resolver service"), styleText("redBright", namespace));
+				console.error(error);
+				if (!watch) throw error;
 			}
-			if (app.authService) await app.authService.resolveNamespaces();
 		}
+		if (app.authService) await app.authService.resolveNamespaces();
 		const executors = await this.application.executorService?.loadExecutors();
 		Object.entries(executors ?? {}).forEach(([filePath, executor]) => {
-			this.executors[filePath] = executor;
+			this.services.executor[filePath] = executor;
 		});
 		await this.processGenerators();
 	}
@@ -6334,84 +6443,75 @@ var GenerationManager = class {
 	async processGenerator(gen) {
 		try {
 			this.generatorResults[gen.id] = {
-				application: {},
+				tailordbResults: {},
+				resolverResults: {},
+				tailordbNamespaceResults: {},
+				resolverNamespaceResults: {},
 				executorResults: {}
 			};
-			for (const [appNamespace, appData] of Object.entries(this.applications)) {
-				this.generatorResults[gen.id].application[appNamespace] = {
-					tailordbResults: {},
-					resolverResults: {},
-					tailordbNamespaceResults: {},
-					resolverNamespaceResults: {}
-				};
-				for (const [namespace, types] of Object.entries(appData.tailordbNamespaces)) await this.processTailorDBNamespace(gen, appNamespace, namespace, types);
-				for (const [namespace, resolvers] of Object.entries(appData.resolverNamespaces)) await this.processResolverNamespace(gen, appNamespace, namespace, resolvers);
-				await this.processExecutors(gen);
-			}
+			for (const [namespace, types] of Object.entries(this.services.tailordb)) await this.processTailorDBNamespace(gen, namespace, types);
+			for (const [namespace, resolvers] of Object.entries(this.services.resolver)) await this.processResolverNamespace(gen, namespace, resolvers);
+			await this.processExecutors(gen);
 			await this.aggregate(gen);
 		} catch (error) {
 			console.error(styleText("red", "Error processing generator"), styleText("redBright", gen.id));
 			console.error(error);
 		}
 	}
-	async processTailorDBNamespace(gen, appNamespace, namespace, typeInfo) {
-		const results = this.generatorResults[gen.id].application[appNamespace];
+	async processTailorDBNamespace(gen, namespace, typeInfo) {
+		const results = this.generatorResults[gen.id];
 		results.tailordbResults[namespace] = {};
 		await Promise.allSettled(Object.entries(typeInfo.types).map(async ([typeName, type]) => {
 			try {
 				results.tailordbResults[namespace][typeName] = await gen.processType({
 					type,
-					applicationNamespace: appNamespace,
 					namespace,
 					source: typeInfo.sourceInfo[typeName]
 				});
 			} catch (error) {
-				console.error(styleText("red", `Error processing type`), styleText("redBright", typeName), styleText("red", `in ${appNamespace}/${namespace} with generator ${gen.id}`));
+				console.error(styleText("red", `Error processing type`), styleText("redBright", typeName), styleText("red", `in ${namespace} with generator ${gen.id}`));
 				console.error(error);
 			}
 		}));
 		if (gen.processTailorDBNamespace) try {
 			results.tailordbNamespaceResults[namespace] = await gen.processTailorDBNamespace({
-				applicationNamespace: appNamespace,
 				namespace,
 				types: results.tailordbResults[namespace]
 			});
 		} catch (error) {
-			console.error(styleText("red", `Error processing TailorDB namespace`), styleText("redBright", namespace), styleText("red", `in ${appNamespace} with generator ${gen.id}`));
+			console.error(styleText("red", `Error processing TailorDB namespace`), styleText("redBright", namespace), styleText("red", `with generator ${gen.id}`));
 			console.error(error);
 		}
 		else results.tailordbNamespaceResults[namespace] = results.tailordbResults[namespace];
 	}
-	async processResolverNamespace(gen, appNamespace, namespace, resolvers) {
-		const results = this.generatorResults[gen.id].application[appNamespace];
+	async processResolverNamespace(gen, namespace, resolvers) {
+		const results = this.generatorResults[gen.id];
 		results.resolverResults[namespace] = {};
 		await Promise.allSettled(Object.entries(resolvers).map(async ([resolverName, resolver]) => {
 			try {
 				results.resolverResults[namespace][resolverName] = await gen.processResolver({
 					resolver,
-					applicationNamespace: appNamespace,
 					namespace
 				});
 			} catch (error) {
-				console.error(styleText("red", `Error processing resolver`), styleText("redBright", resolverName), styleText("red", `in ${appNamespace}/${namespace} with generator ${gen.id}`));
+				console.error(styleText("red", `Error processing resolver`), styleText("redBright", resolverName), styleText("red", `in ${namespace} with generator ${gen.id}`));
 				console.error(error);
 			}
 		}));
 		if (gen.processResolverNamespace) try {
 			results.resolverNamespaceResults[namespace] = await gen.processResolverNamespace({
-				applicationNamespace: appNamespace,
 				namespace,
 				resolvers: results.resolverResults[namespace]
 			});
 		} catch (error) {
-			console.error(styleText("red", `Error processing Resolver namespace`), styleText("redBright", namespace), styleText("red", `in ${appNamespace} with generator ${gen.id}`));
+			console.error(styleText("red", `Error processing Resolver namespace`), styleText("redBright", namespace), styleText("red", `with generator ${gen.id}`));
 			console.error(error);
 		}
 		else results.resolverNamespaceResults[namespace] = results.resolverResults[namespace];
 	}
 	async processExecutors(gen) {
 		const results = this.generatorResults[gen.id];
-		await Promise.allSettled(Object.entries(this.executors).map(async ([executorId, executor]) => {
+		await Promise.allSettled(Object.entries(this.services.executor).map(async ([executorId, executor]) => {
 			try {
 				results.executorResults[executorId] = await gen.processExecutor(executor);
 			} catch (error) {
@@ -6420,28 +6520,42 @@ var GenerationManager = class {
 			}
 		}));
 	}
+	getAuthInput() {
+		const authService = this.application.authService;
+		if (!authService) return void 0;
+		const config = authService.config;
+		return {
+			name: config.name,
+			userProfile: authService.userProfile ? {
+				typeName: authService.userProfile.type.name,
+				namespace: authService.userProfile.namespace,
+				usernameField: authService.userProfile.usernameField
+			} : void 0,
+			machineUsers: config.machineUsers,
+			oauth2Clients: config.oauth2Clients,
+			idProvider: config.idProvider
+		};
+	}
 	async aggregate(gen) {
-		const inputs = [];
-		for (const [appNamespace, results] of Object.entries(this.generatorResults[gen.id].application)) {
-			const tailordbResults = [];
-			const resolverResults = [];
-			for (const [namespace, types] of Object.entries(results.tailordbNamespaceResults)) tailordbResults.push({
-				namespace,
-				types
-			});
-			for (const [namespace, resolvers] of Object.entries(results.resolverNamespaceResults)) resolverResults.push({
-				namespace,
-				resolvers
-			});
-			inputs.push({
-				applicationNamespace: appNamespace,
-				tailordb: tailordbResults,
-				resolver: resolverResults
-			});
-		}
+		const results = this.generatorResults[gen.id];
+		const tailordbResults = [];
+		const resolverResults = [];
+		for (const [namespace, types] of Object.entries(results.tailordbNamespaceResults)) tailordbResults.push({
+			namespace,
+			types
+		});
+		for (const [namespace, resolvers] of Object.entries(results.resolverNamespaceResults)) resolverResults.push({
+			namespace,
+			resolvers
+		});
+		const input = {
+			tailordb: tailordbResults,
+			resolver: resolverResults,
+			auth: this.getAuthInput()
+		};
 		const result = await gen.aggregate({
-			inputs,
-			executorInputs: Object.values(this.generatorResults[gen.id].executorResults),
+			input,
+			executorInputs: Object.values(results.executorResults),
 			baseDir: path.join(this.baseDir, gen.id)
 		});
 		await Promise.all(result.files.map(async (file) => {
@@ -6483,15 +6597,14 @@ var GenerationManager = class {
 			this.restartWatchProcess();
 		});
 		if (this.configPath) await this.watcher.addWatchGroup("Config", [this.configPath]);
-		for (const app of this.application.applications) {
-			for (const db of app.tailorDBServices) {
-				const dbNamespace = db.namespace;
-				await this.watcher?.addWatchGroup(`TailorDB/${dbNamespace}`, db.config.files);
-			}
-			for (const resolverService of app.resolverServices) {
-				const resolverNamespace = resolverService.namespace;
-				await this.watcher?.addWatchGroup(`Resolver/${resolverNamespace}`, resolverService["config"].files);
-			}
+		const app = this.application;
+		for (const db of app.tailorDBServices) {
+			const dbNamespace = db.namespace;
+			await this.watcher?.addWatchGroup(`TailorDB/${dbNamespace}`, db.config.files);
+		}
+		for (const resolverService of app.resolverServices) {
+			const resolverNamespace = resolverService.namespace;
+			await this.watcher?.addWatchGroup(`Resolver/${resolverNamespace}`, resolverService["config"].files);
 		}
 		await new Promise(() => {});
 	}
@@ -6828,7 +6941,7 @@ async function workspaceList() {
 		return [workspaces, nextPageToken];
 	})).map(workspaceInfo);
 }
-const listCommand$1 = defineCommand({
+const listCommand$2 = defineCommand({
 	meta: {
 		name: "list",
 		description: "List all Tailor Platform workspaces"
@@ -6935,7 +7048,7 @@ async function machineUserList(options) {
 		return [machineUsers, nextPageToken];
 	})).map(machineUserInfo);
 }
-const listCommand = defineCommand({
+const listCommand$1 = defineCommand({
 	meta: {
 		name: "list",
 		description: "List all machine users"
@@ -7053,5 +7166,173 @@ const tokenCommand = defineCommand({
 });
 
 //#endregion
-export { PATScope, apply, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, fetchUserInfo, formatArgs, generate, generateCommand, generateUserTypes, initOAuth2Client, initOperatorClient, listCommand, listCommand$1, loadAccessToken, loadConfig, loadConfigPath, loadWorkspaceId, machineUserList, machineUserToken, parseFormat, printWithFormat, readPackageJson, readPlatformConfig, remove, removeCommand, show, showCommand, tokenCommand, withCommonArgs, workspaceCreate, workspaceDelete, workspaceList, writePlatformConfig };
-//# sourceMappingURL=token-BJq9rpG5.mjs.map
+//#region src/cli/oauth2client/transform.ts
+const grantTypeToString = (grantType) => {
+	switch (grantType) {
+		case AuthOAuth2Client_GrantType.AUTHORIZATION_CODE: return "authorization_code";
+		case AuthOAuth2Client_GrantType.REFRESH_TOKEN: return "refresh_token";
+		default: return "unknown";
+	}
+};
+function toOAuth2ClientInfo(client) {
+	return {
+		name: client.name,
+		description: client.description,
+		clientId: client.clientId,
+		grantTypes: client.grantTypes.map(grantTypeToString),
+		redirectUris: client.redirectUris,
+		createdAt: client.createdAt ? timestampDate(client.createdAt).toISOString() : "N/A"
+	};
+}
+function toOAuth2ClientCredentials(client) {
+	return {
+		name: client.name,
+		description: client.description,
+		clientId: client.clientId,
+		clientSecret: client.clientSecret,
+		grantTypes: client.grantTypes.map(grantTypeToString),
+		redirectUris: client.redirectUris,
+		createdAt: client.createdAt ? timestampDate(client.createdAt).toISOString() : "N/A"
+	};
+}
+
+//#endregion
+//#region src/cli/oauth2client/get.ts
+async function oauth2ClientGet(options) {
+	const accessToken = await loadAccessToken({
+		useProfile: true,
+		profile: options.profile
+	});
+	const client = await initOperatorClient(accessToken);
+	const workspaceId = loadWorkspaceId({
+		workspaceId: options.workspaceId,
+		profile: options.profile
+	});
+	const configPath = loadConfigPath(options.configPath);
+	const { config } = await loadConfig(configPath);
+	const { application } = await client.getApplication({
+		workspaceId,
+		applicationName: config.name
+	});
+	if (!application?.authNamespace) throw new Error(`Application ${config.name} does not have an auth configuration.`);
+	try {
+		const { oauth2Client } = await client.getAuthOAuth2Client({
+			workspaceId,
+			namespaceName: application.authNamespace,
+			name: options.name
+		});
+		return toOAuth2ClientCredentials(oauth2Client);
+	} catch (error) {
+		if (error instanceof ConnectError && error.code === Code.NotFound) throw new Error(`OAuth2 client '${options.name}' not found.`);
+		throw error;
+	}
+}
+const getCommand = defineCommand({
+	meta: {
+		name: "get",
+		description: "Get OAuth2 client credentials"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs,
+		name: {
+			type: "positional",
+			description: "OAuth2 client name",
+			required: true
+		},
+		"workspace-id": {
+			type: "string",
+			description: "Workspace ID",
+			alias: "w"
+		},
+		profile: {
+			type: "string",
+			description: "Workspace profile",
+			alias: "p"
+		},
+		config: {
+			type: "string",
+			description: "Path to SDK config file",
+			alias: "c",
+			default: "tailor.config.ts"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const credentials = await oauth2ClientGet({
+			name: args.name,
+			workspaceId: args["workspace-id"],
+			profile: args.profile,
+			configPath: args.config
+		});
+		printWithFormat(credentials, format);
+	})
+});
+
+//#endregion
+//#region src/cli/oauth2client/list.ts
+async function oauth2ClientList(options) {
+	const accessToken = await loadAccessToken({
+		useProfile: true,
+		profile: options?.profile
+	});
+	const client = await initOperatorClient(accessToken);
+	const workspaceId = loadWorkspaceId({
+		workspaceId: options?.workspaceId,
+		profile: options?.profile
+	});
+	const configPath = loadConfigPath(options?.configPath);
+	const { config } = await loadConfig(configPath);
+	const { application } = await client.getApplication({
+		workspaceId,
+		applicationName: config.name
+	});
+	if (!application?.authNamespace) throw new Error(`Application ${config.name} does not have an auth configuration.`);
+	return (await fetchAll(async (pageToken) => {
+		const { oauth2Clients, nextPageToken } = await client.listAuthOAuth2Clients({
+			workspaceId,
+			pageToken,
+			namespaceName: application.authNamespace
+		});
+		return [oauth2Clients, nextPageToken];
+	})).map(toOAuth2ClientInfo);
+}
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all OAuth2 clients"
+	},
+	args: {
+		...commonArgs,
+		...formatArgs,
+		"workspace-id": {
+			type: "string",
+			description: "Workspace ID",
+			alias: "w"
+		},
+		profile: {
+			type: "string",
+			description: "Workspace profile",
+			alias: "p"
+		},
+		config: {
+			type: "string",
+			description: "Path to SDK config file",
+			alias: "c",
+			default: "tailor.config.ts"
+		}
+	},
+	run: withCommonArgs(async (args) => {
+		const format = parseFormat(args.format);
+		const oauth2Clients = await oauth2ClientList({
+			workspaceId: args["workspace-id"],
+			profile: args.profile,
+			configPath: args.config
+		});
+		printWithFormat(oauth2Clients, format);
+	})
+});
+
+//#endregion
+export { PATScope, apply, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, fetchUserInfo, formatArgs, generate, generateCommand, generateUserTypes, getCommand, initOAuth2Client, initOperatorClient, listCommand, listCommand$1, listCommand$2, loadAccessToken, loadConfig, loadConfigPath, loadWorkspaceId, machineUserList, machineUserToken, oauth2ClientGet, oauth2ClientList, parseFormat, printWithFormat, readPackageJson, readPlatformConfig, remove, removeCommand, show, showCommand, tokenCommand, withCommonArgs, workspaceCreate, workspaceDelete, workspaceList, writePlatformConfig };
+//# sourceMappingURL=list-6vWylIIR.mjs.map