@tailor-platform/sdk 1.22.0 → 1.23.0

package/dist/{query-Bz2oDGhw.mjs → query-BLQBOaAM.mjs}

@@ -2,7 +2,6 @@ import { t as db } from "./schema-Cjm-OvPF.mjs";
 import { $ as AuthSCIMAttribute_Mutability, A as platformBaseUrl, B as TailorDBType_Permission_Permit, C as readPlatformConfig, E as fetchMachineUserToken, F as WorkflowJobExecution_Status, H as PipelineResolver_OperationType, I as TailorDBGQLPermission_Action, J as ExecutorTriggerType, K as ExecutorJobStatus, L as TailorDBGQLPermission_Operator, M as userAgent, N as WorkspacePlatformUserRole, P as WorkflowExecution_Status, Q as AuthOAuth2Client_GrantType, R as TailorDBGQLPermission_Permit, S as loadWorkspaceId, T as fetchAll, U as IdPLang, V as TailorDBType_PermitAction, W as FunctionExecution_Status, X as AuthInvokerSchema, Y as AuthIDPConfig_AuthType, Z as AuthOAuth2Client_ClientType, _ as hashFile, a as loadConfig, at as UserProfileProviderConfig_UserProfileProviderType, b as loadFolderId, ct as Condition_Operator, d as TailorDBTypeSchema, dt as ApplicationSchemaUpdateAttemptStatus, et as AuthSCIMAttribute_Type, f as stringifyFunction, ft as Subgraph_ServiceType, g as getDistDir, h as createBundleCache, ht as symbols, it as TenantProviderConfig_TenantProviderType, j as resolveStaticWebsiteUrls, k as initOperatorClient, l as OAuth2ClientSchema, lt as FilterSchema, m as loadFilesWithIgnores, mt as styles, n as generatePluginFilesIfNeeded, nt as AuthSCIMConfig_AuthorizationType, ot as GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus, p as tailorUserMap, pt as logger, q as ExecutorTargetType, r as loadApplication, s as createExecutorService, st as ConditionSchema, t as defineApplication, tt as AuthSCIMAttribute_Uniqueness, ut as PageDirection, w as writePlatformConfig, x as loadOrganizationId, y as loadAccessToken, z as TailorDBType_Permission_Operator } from "./application-CTQe2HSB.mjs";
 import { t as readPackageJson } from "./package-json-iVBhE5Ef.mjs";
 import { r as withSpan } from "./telemetry-C46fds1l.mjs";
-import { createRequire } from "node:module";
 import { arg, defineCommand, runCommand } from "politty";
 import { z } from "zod";
 import * as fs$1 from "node:fs";
@@ -28,7 +27,9 @@ import { setTimeout as setTimeout$1 } from "timers/promises";
 import { spawn } from "node:child_process";
 import { watch } from "chokidar";
 import * as madgeModule from "madge";
+import { createInterface } from "node:readline/promises";
 import { astVisitor, parse, toSql } from "pgsql-ast-parser";
+import { parse as parse$1 } from "@0no-co/graphql.web";
 
 //#region src/cli/shared/errors.ts
 /**
@@ -519,7 +520,6 @@ export {};
 
 `;
 }
-const require = createRequire(import.meta.url);
 function collectAttributesFromConfig(config) {
 	const auth = config.auth;
 	if (!auth || typeof auth !== "object") return {};
@@ -562,12 +562,7 @@ function collectAttributesFromConfig(config) {
 * @returns Absolute path to the type definition file
 */
 function resolveTypeDefinitionPath(configPath) {
-	const typePath = process.env.TAILOR_PLATFORM_SDK_TYPE_PATH;
-	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", "user-defined.d.ts");
-	return path.join(packageDir, "dist", "user-defined.d.ts");
+	return path.join(path.dirname(path.resolve(configPath)), "tailor.d.ts");
 }
 /**
 * Generate user type definitions from the app config and write them to disk.
@@ -595,23 +590,6 @@ async function generateUserTypes(options) {
 		logger.error(String(error));
 	}
 }
-function resolvePackageDirectory(startDir) {
-	let currentDir = startDir;
-	const root = path.parse(currentDir).root;
-	while (true) {
-		const candidate = path.join(currentDir, "node_modules", "@tailor-platform", "sdk");
-		const packageJsonPath = path.join(candidate, "package.json");
-		if (fs$1.existsSync(packageJsonPath)) return candidate;
-		if (currentDir === root) break;
-		currentDir = path.dirname(currentDir);
-	}
-	try {
-		const resolved = require.resolve("@tailor-platform/sdk/package.json", { paths: [startDir] });
-		return path.dirname(resolved);
-	} catch {
-		return null;
-	}
-}
 
 //#endregion
 //#region src/parser/plugin-config/generation-types.ts
@@ -11451,6 +11429,118 @@ function mapQueryExecutionError(args) {
 	return args.error instanceof Error ? args.error : new Error(message);
 }
 
+//#endregion
+//#region src/cli/query/graphql-repl.ts
+/**
+* Return true when the buffered GraphQL input parses as a complete document.
+* @param input - Buffered GraphQL input
+* @returns True when the GraphQL document is complete and ready to execute
+*/
+function isGraphQLInputComplete(input) {
+	if (input.trim().length === 0) return false;
+	try {
+		parse$1(input);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/cli/query/sql-repl.ts
+/**
+* Return true when the buffered SQL input ends with a real statement terminator.
+* @param input - Buffered SQL input
+* @returns True when the SQL statement is complete and ready to execute
+*/
+function isSqlInputComplete(input) {
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let inLineComment = false;
+	let blockCommentDepth = 0;
+	let dollarQuoteTag = null;
+	let lastSignificantTokenWasSemicolon = false;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		const next = input[i + 1];
+		if (inLineComment) {
+			if (char === "\n") inLineComment = false;
+			continue;
+		}
+		if (blockCommentDepth > 0) {
+			if (char === "/" && next === "*") {
+				blockCommentDepth += 1;
+				i += 1;
+				continue;
+			}
+			if (char === "*" && next === "/") {
+				blockCommentDepth -= 1;
+				i += 1;
+			}
+			continue;
+		}
+		if (dollarQuoteTag != null) {
+			if (input.startsWith(dollarQuoteTag, i)) {
+				i += dollarQuoteTag.length - 1;
+				dollarQuoteTag = null;
+			}
+			continue;
+		}
+		if (inSingleQuote) {
+			if (char === "'" && next === "'") {
+				i += 1;
+				continue;
+			}
+			if (char === "'") inSingleQuote = false;
+			continue;
+		}
+		if (inDoubleQuote) {
+			if (char === "\"" && next === "\"") {
+				i += 1;
+				continue;
+			}
+			if (char === "\"") inDoubleQuote = false;
+			continue;
+		}
+		if (char === "-" && next === "-") {
+			inLineComment = true;
+			i += 1;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			blockCommentDepth = 1;
+			i += 1;
+			continue;
+		}
+		if (char === "'") {
+			lastSignificantTokenWasSemicolon = false;
+			inSingleQuote = true;
+			continue;
+		}
+		if (char === "\"") {
+			lastSignificantTokenWasSemicolon = false;
+			inDoubleQuote = true;
+			continue;
+		}
+		if (char === "$") {
+			const rest = input.slice(i);
+			const match = rest.match(/^\$[A-Za-z_][A-Za-z0-9_]*\$/) ?? rest.match(/^\$\$/);
+			if (match != null) {
+				lastSignificantTokenWasSemicolon = false;
+				dollarQuoteTag = match[0];
+				i += match[0].length - 1;
+				continue;
+			}
+		}
+		if (char === ";") {
+			lastSignificantTokenWasSemicolon = true;
+			continue;
+		}
+		if (!/\s/.test(char)) lastSignificantTokenWasSemicolon = false;
+	}
+	return lastSignificantTokenWasSemicolon && !inSingleQuote && !inDoubleQuote && blockCommentDepth === 0 && dollarQuoteTag == null;
+}
+
 //#endregion
 //#region src/cli/query/sql-type-extractor.ts
 /**
@@ -11560,14 +11650,14 @@ async function loadTypeFieldOrder(config, namespace) {
 //#endregion
 //#region src/cli/query/index.ts
 const queryEngineSchema = z.enum(["sql", "gql"]);
-const queryOptionsSchema = z.object({
+const queryBaseOptionsSchema = z.object({
 	workspaceId: z.string().optional(),
 	profile: z.string().optional(),
 	configPath: z.string().optional(),
 	engine: queryEngineSchema,
-	query: z.string(),
 	machineUser: z.string()
 });
+const queryOptionsSchema = queryBaseOptionsSchema.extend({ query: z.string() });
 async function getNamespaceFromSqlQuery(workspaceId, query$1, client, namespaces) {
 	if (namespaces.length === 0) throw new Error("No namespaces found in configuration.");
 	if (namespaces.length === 1) return namespaces[0];
@@ -11586,7 +11676,7 @@ async function getNamespaceFromSqlQuery(workspaceId, query$1, client, namespaces
 	throw new Error(`Query references types from multiple namespaces: ${[...namespacesFromTypes].join(", ")}.`);
 }
 async function loadOptions(options) {
-	const result = queryOptionsSchema.safeParse(options);
+	const result = queryBaseOptionsSchema.safeParse(options);
 	if (!result.success) throw new Error(result.error.issues[0].message);
 	const client = await initOperatorClient(await loadAccessToken({
 		useProfile: true,
@@ -11609,23 +11699,14 @@ async function loadOptions(options) {
 		name: result.data.machineUser
 	});
 	if (!machineUserResource) throw new Error(`Machine user ${result.data.machineUser} not found.`);
-	if (options.engine === "gql") return {
-		engine: options.engine,
-		client,
-		workspaceId,
-		config,
-		application,
-		machineUserResource
-	};
-	const namespace = await getNamespaceFromSqlQuery(workspaceId, result.data.query, client, namespaces);
 	return {
-		engine: options.engine,
+		engine: result.data.engine,
 		client,
 		workspaceId,
 		config,
 		application,
 		machineUserResource,
-		namespace
+		namespaces
 	};
 }
 async function sqlQuery(client, invoker, args) {
@@ -11679,40 +11760,204 @@ function parseExecutionResult(result) {
 	}
 }
 /**
+* Resolve query input mode from CLI args.
+* @param args - Query input flags
+* @param args.query - Direct query string
+* @returns Normalized input mode
+*/
+function resolveQueryCommandInput(args) {
+	if (args.query != null) return { query: args.query };
+	return { query: void 0 };
+}
+/**
 * Dispatch query execution.
 * @param options - Query command options
 * @returns Dispatch result
 */
 async function query(options) {
-	const { client, workspaceId, config, application, machineUserResource, engine, namespace } = await loadOptions(options);
-	try {
-		const bundledCode = await bundleQueryScript(engine);
-		const invoker = create(AuthInvokerSchema, {
-			namespace: application.authNamespace,
-			machineUserName: machineUserResource.name
-		});
-		switch (engine) {
-			case "sql": return reorderSqlColumns(await sqlQuery(client, invoker, {
-				workspaceId,
+	const result = queryOptionsSchema.safeParse(options);
+	if (!result.success) throw new Error(result.error.issues[0].message);
+	return await (await prepareQueryExecutor(result.data))(result.data.query);
+}
+async function prepareQueryExecutor(options) {
+	const { client, workspaceId, config, application, machineUserResource, engine, namespaces } = await loadOptions(options);
+	const bundledCode = await bundleQueryScript(engine);
+	const invoker = create(AuthInvokerSchema, {
+		namespace: application.authNamespace,
+		machineUserName: machineUserResource.name
+	});
+	return async (queryString) => {
+		let namespace;
+		try {
+			switch (engine) {
+				case "sql":
+					namespace = await getNamespaceFromSqlQuery(workspaceId, queryString, client, namespaces);
+					return reorderSqlColumns(await sqlQuery(client, invoker, {
+						workspaceId,
+						namespace,
+						bundledCode,
+						query: queryString
+					}), config, namespace, queryString);
+				case "gql": return await gqlQuery(client, invoker, application, machineUserResource, {
+					workspaceId,
+					bundledCode,
+					query: queryString
+				});
+				default: throw new Error(`Unsupported query engine: ${engine}`);
+			}
+		} catch (error) {
+			throw mapQueryExecutionError({
+				error,
+				engine,
 				namespace,
-				bundledCode,
-				query: options.query
-			}), config, namespace, options.query);
-			case "gql": return await gqlQuery(client, invoker, application, machineUserResource, {
-				workspaceId,
-				bundledCode,
-				query: options.query
+				machineUser: options.machineUser
 			});
-			default: throw new Error(`Unsupported query engine: ${engine}`);
 		}
-	} catch (error) {
-		throw mapQueryExecutionError({
-			error,
-			engine,
-			namespace,
-			machineUser: options.machineUser
-		});
+	};
+}
+function isReadlineTerminationError(error) {
+	if (!(error instanceof Error) || !("code" in error)) return false;
+	return error.code === "ABORT_ERR" || error.code === "ERR_USE_AFTER_CLOSE";
+}
+/**
+* Resolve a backslash REPL command into its normalized action.
+* @param input - Raw user input
+* @returns Normalized REPL command, or null for non-command input
+*/
+function resolveReplCommand(input) {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("\\")) return null;
+	if (trimmed === "\\q" || trimmed === "\\quit") return "quit";
+	if (trimmed === "\\help" || trimmed === "\\h" || trimmed === "\\?") return "help";
+	if (trimmed === "\\clear" || trimmed === "\\c") return "clear";
+	return "unknown";
+}
+/**
+* Decide how REPL should react to Ctrl+C based on current buffered input.
+* @param bufferedLines - Previously accepted lines in the current statement buffer
+* @param currentLine - In-progress line currently being edited
+* @returns Whether to clear the buffer or exit the REPL
+*/
+function resolveReplInterruptAction(bufferedLines, currentLine) {
+	if (bufferedLines.length === 0 && currentLine.length === 0) return "exit";
+	return "clear";
+}
+/**
+* Clear the interactive terminal screen and move the cursor to the top-left.
+*/
+function clearReplScreen() {
+	process.stdout.write("\x1Bc");
+}
+async function runRepl(options) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Non-interactive terminals are not supported. Pass -q/--query to run a query.");
+	const execute = await prepareQueryExecutor(options);
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	logger.info(`Entering ${options.engine.toUpperCase()} REPL mode.`);
+	logger.info("Type \\help for usage, \\q to quit.");
+	const lines = [];
+	try {
+		while (true) {
+			const prompt = lines.length === 0 ? `${options.engine}> ` : " ";
+			let line;
+			let interruptAction = null;
+			const controller = new AbortController();
+			const handleSigint = () => {
+				interruptAction = resolveReplInterruptAction(lines, rl.line);
+				if (interruptAction === "clear") {
+					lines.length = 0;
+					rl.write(null, {
+						ctrl: true,
+						name: "u"
+					});
+					process.stdout.write("\n");
+				} else rl.close();
+				controller.abort();
+			};
+			rl.once("SIGINT", handleSigint);
+			try {
+				line = await rl.question(prompt, { signal: controller.signal });
+			} catch (error) {
+				rl.off("SIGINT", handleSigint);
+				if (controller.signal.aborted) {
+					if (interruptAction === "exit") return;
+					continue;
+				}
+				if (isReadlineTerminationError(error)) return;
+				throw error;
+			} finally {
+				rl.off("SIGINT", handleSigint);
+			}
+			const trimmed = line.trim();
+			if (lines.length === 0 && trimmed === "") continue;
+			if (lines.length === 0) {
+				const command = resolveReplCommand(trimmed);
+				if (command === "quit") return;
+				if (command === "help") {
+					printReplHelp(options.engine);
+					continue;
+				}
+				if (command === "clear") {
+					clearReplScreen();
+					continue;
+				}
+				if (command === "unknown") {
+					logger.warn(`Unknown command: ${trimmed}`);
+					continue;
+				}
+			}
+			lines.push(line);
+			if (options.engine === "sql") {
+				if (!isSqlInputComplete(lines.join("\n"))) continue;
+			} else if (!isGraphQLInputComplete(lines.join("\n"))) continue;
+			const statement = getReplStatement(lines, options.engine);
+			lines.length = 0;
+			if (statement.length === 0) continue;
+			try {
+				if (options.engine === "sql") {
+					const result$1 = await execute(statement);
+					if (result$1.engine !== "sql") throw new Error(`Expected sql engine result but got: ${result$1.engine}`);
+					printSqlResult(result$1, { json: options.json });
+					continue;
+				}
+				const result = await execute(statement);
+				if (result.engine !== "gql") throw new Error(`Expected gql engine result but got: ${result.engine}`);
+				printGqlResult(result, { json: options.json });
+			} catch (error) {
+				if (isCLIError(error)) {
+					logger.log(error.format());
+					continue;
+				}
+				if (error instanceof Error) {
+					logger.error(error.message);
+					continue;
+				}
+				logger.error(String(error));
+			}
+		}
+	} finally {
+		rl.close();
+	}
+}
+function getReplStatement(lines, engine) {
+	if (engine === "sql") return lines.join("\n").trim();
+	let end = lines.length;
+	while (end > 0 && lines[end - 1].trim() === "") end -= 1;
+	return lines.slice(0, end).join("\n").trim();
+}
+function printReplHelp(engine) {
+	logger.log("REPL commands:");
+	logger.log("  \\help, \\h, \\?         Show this help");
+	logger.log("  Ctrl+C                Clear current input");
+	logger.log("  \\q, \\quit, Ctrl+D     Exit REPL");
+	logger.log("  \\clear, \\c            Clear the screen");
+	if (engine === "sql") {
+		logger.log("SQL execution: statement ending with ';' runs immediately.");
+		return;
 	}
+	logger.log("GraphQL execution: a complete GraphQL document runs immediately.");
 }
 /**
 * Execute SQL query directly.
@@ -11793,9 +12038,9 @@ const queryCommand = defineCommand({
 		...jsonArgs,
 		...deploymentArgs,
 		engine: arg(queryEngineSchema, { description: "Query engine (sql or gql)" }),
-		query: arg(z.string(), {
+		query: arg(z.string().optional(), {
 			alias: "q",
-			description: "Query string to execute directly"
+			description: "Query string to execute directly; omit to start REPL mode"
 		}),
 		machineuser: arg(z.string(), {
 			alias: "m",
@@ -11803,18 +12048,33 @@ const queryCommand = defineCommand({
 		})
 	}).strict(),
 	run: withCommonArgs(async (args) => {
+		const mode = resolveQueryCommandInput({ query: args.query });
 		const sharedOptions = {
 			workspaceId: args["workspace-id"],
 			profile: args.profile,
 			configPath: args.config,
-			query: args.query,
+			engine: args.engine,
 			machineUser: args.machineuser
 		};
+		if (mode.query == null) {
+			await runRepl({
+				...sharedOptions,
+				json: args.json
+			});
+			return;
+		}
+		const directQuery = mode.query;
 		if (args.engine === "sql") {
-			printSqlResult(await querySql(sharedOptions), { json: args.json });
+			printSqlResult(await querySql({
+				...sharedOptions,
+				query: directQuery
+			}), { json: args.json });
 			return;
 		}
-		printGqlResult(await queryGql(sharedOptions), { json: args.json });
+		printGqlResult(await queryGql({
+			...sharedOptions,
+			query: directQuery
+		}), { json: args.json });
 	})
 });
 function isSQLExecutionResult(value) {
@@ -11894,4 +12154,4 @@ function printGqlResult(result, options = {}) {
 
 //#endregion
 export { getExecutorJob as $, truncateCommand as A, getMigrationDirPath as At, getCommand$1 as B, getNamespacesWithMigrations as Bt, getAppHealth as C, MIGRATE_FILE_NAME as Ct, listCommand$3 as D, createSnapshotFromLocalTypes as Dt, resumeWorkflow as E, compareSnapshots as Et, showCommand as F, loadDiff as Ft, listMachineUsers as G, commonArgs as Gt, getMachineUserToken as H, generateUserTypes as Ht, remove as I, reconstructSnapshotFromMigrations as It, webhookCommand as J, jsonArgs as Jt, generate$1 as K, confirmationArgs as Kt, removeCommand$1 as L, formatDiffSummary as Lt, generateCommand as M, getMigrationFiles as Mt, logBetaWarning as N, getNextMigrationNumber as Nt, listWorkflows as O, formatMigrationNumber as Ot, show as P, isValidMigrationNumber as Pt, listExecutors as Q, listCommand$4 as R, formatMigrationDiff as Rt, listCommand$2 as S, INITIAL_SCHEMA_NUMBER as St, resumeCommand as T, compareLocalTypesWithSnapshot as Tt, tokenCommand as U, apiCall as Ut, getOAuth2Client as V, trnPrefix as Vt, listCommand$5 as W, apiCommand as Wt, triggerExecutor as X, workspaceArgs as Xt, triggerCommand as Y, withCommonArgs as Yt, listCommand$6 as Z, deleteCommand as _, MIGRATION_LABEL_KEY as _t, removeCommand as a, getCommand$2 as at, createWorkspace as b, DB_TYPES_FILE_NAME as bt, listUsers as c, getWorkflowExecution as ct, restoreCommand as d, formatKeyValueTable as dt, jobsCommand as et, restoreWorkspace as f, getCommand$3 as ft, getWorkspace as g, waitForExecution$1 as gt, getCommand as h, executeScript as ht, updateUser as i, startWorkflow as it, generate as j, getMigrationFilePath as jt, truncate as k, getLatestMigrationNumber as kt, inviteCommand as l, listWorkflowExecutions as lt, listWorkspaces as m, apply as mt, queryCommand as n, watchExecutorJob as nt, removeUser as o, getWorkflow as ot, listCommand$1 as p, getExecutor as pt, listWebhookExecutors as q, deploymentArgs as qt, updateCommand as r, startCommand as rt, listCommand as s, executionsCommand as st, query as t, listExecutorJobs as tt, inviteUser as u, functionExecutionStatusToString as ut, deleteWorkspace as v, parseMigrationLabelNumber as vt, healthCommand as w, SCHEMA_FILE_NAME as wt, listApps as x, DIFF_FILE_NAME as xt, createCommand as y, bundleMigrationScript as yt, listOAuth2Clients as z, hasChanges as zt };
-//# sourceMappingURL=query-Bz2oDGhw.mjs.map
+//# sourceMappingURL=query-BLQBOaAM.mjs.map