@tailor-platform/sdk 0.22.2 → 0.22.4

package/dist/{list-CqNMJdug.mjs → list-BSi-MJbT.mjs}

@@ -1,10 +1,10 @@
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __export, t as __commonJSMin } from "./chunk-DhYkiPYI.mjs";
-import { i as WORKFLOW_JOB_BRAND, r as getDistDir } from "./config-BYrX78K0.mjs";
+import { i as WORKFLOW_JOB_BRAND, r as getDistDir } from "./config-CtRi0Lgg.mjs";
 import Module, { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import * as path$20 from "node:path";
 import path from "node:path";
-import process$1, { loadEnvFile } from "node:process";
+import { loadEnvFile } from "node:process";
 import { z } from "zod";
 import chalk from "chalk";
 import { createConsola } from "consola";
@@ -19,13 +19,14 @@ import fs from "node:fs";
 import * as os$3 from "node:os";
 import os from "node:os";
 import { parseTOML, parseYAML, stringifyYAML } from "confbox";
-import fsPromises, { glob } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { findUpSync } from "find-up-simple";
 import ml from "multiline-ts";
 import { xdgConfig } from "xdg-basedir";
-import * as inflection from "inflection";
+import { pathToFileURL } from "node:url";
+import { glob } from "node:fs/promises";
 import util from "node:util";
 import assert from "node:assert";
+import * as inflection from "inflection";
 import * as rolldown from "rolldown";
 import { parseSync } from "oxc-parser";
 import { create, fromJson } from "@bufbuild/protobuf";
@@ -1211,25 +1212,6 @@ async function fetchMachineUserToken(url, clientId, clientSecret) {
 	}).parse(rawJson);
 }
 
-//#endregion
-//#region ../../node_modules/find-up-simple/index.js
-const toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-function findUpSync(name$1, { cwd = process$1.cwd(), type = "file", stopAt } = {}) {
-	let directory = path.resolve(toPath(cwd) ?? "");
-	const { root } = path.parse(directory);
-	stopAt = path.resolve(directory, toPath(stopAt) ?? root);
-	const isAbsoluteName = path.isAbsolute(name$1);
-	while (directory) {
-		const filePath = isAbsoluteName ? name$1 : path.join(directory, name$1);
-		try {
-			const stats = fs.statSync(filePath, { throwIfNoEntry: false });
-			if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) return filePath;
-		} catch {}
-		if (directory === stopAt || directory === root) break;
-		directory = path.dirname(directory);
-	}
-}
-
 //#endregion
 //#region src/cli/context.ts
 const pfConfigSchema = z.object({
@@ -87997,7 +87979,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 	*/
 	async function globMatch({ basePath, pattern }) {
 		let found = false;
-		const { hfs } = await import("./src-DqwtAff-.mjs");
+		const { hfs } = await import("./src-BU1BDRRs.mjs");
 		const matcher = new Minimatch(normalizeToPosix(path$9.relative(basePath, pattern)), MINIMATCH_OPTIONS);
 		const walkSettings = {
 			directoryFilter(entry) {
@@ -88044,7 +88026,7 @@ var require_eslint_helpers = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 			return new Minimatch(patternToUse, MINIMATCH_OPTIONS);
 		});
 		const unmatchedPatterns = new Set([...relativeToPatterns.keys()]);
-		const { hfs } = await import("./src-DqwtAff-.mjs");
+		const { hfs } = await import("./src-BU1BDRRs.mjs");
 		const walk = hfs.walk(basePath, {
 			async directoryFilter(entry) {
 				if (!matchers.some((matcher) => matcher.match(entry.path, true))) return false;
@@ -98113,6 +98095,230 @@ function ensureNoExternalVariablesInFieldScripts(typeName, fieldName, fieldConfi
 	});
 }
 
+//#endregion
+//#region src/parser/service/tailordb/permission.ts
+const operatorMap = {
+	"=": "eq",
+	"!=": "ne",
+	in: "in",
+	"not in": "nin"
+};
+function normalizeOperand(operand) {
+	if (typeof operand === "object" && "user" in operand) return { user: operand.user === "id" ? "_id" : operand.user };
+	return operand;
+}
+function normalizeConditions(conditions) {
+	return conditions.map((cond) => {
+		const [left, operator, right] = cond;
+		return [
+			normalizeOperand(left),
+			operatorMap[operator],
+			normalizeOperand(right)
+		];
+	});
+}
+function isObjectFormat(p$1) {
+	return typeof p$1 === "object" && p$1 !== null && "conditions" in p$1;
+}
+function isSingleArrayConditionFormat(cond) {
+	return cond.length >= 2 && typeof cond[1] === "string";
+}
+function normalizePermission(permission) {
+	return Object.keys(permission).reduce((acc, action) => {
+		acc[action] = permission[action].map((p$1) => normalizeActionPermission(p$1));
+		return acc;
+	}, {});
+}
+function normalizeGqlPermission(permission) {
+	return permission.map((policy) => normalizeGqlPolicy(policy));
+}
+function normalizeGqlPolicy(policy) {
+	return {
+		conditions: policy.conditions ? normalizeConditions(policy.conditions) : [],
+		actions: policy.actions === "all" ? ["all"] : policy.actions,
+		permit: policy.permit ? "allow" : "deny",
+		description: policy.description
+	};
+}
+/**
+* Parse raw permissions into normalized permissions.
+* This is the main entry point for permission parsing in the parser layer.
+*/
+function parsePermissions(rawPermissions) {
+	return {
+		...rawPermissions.record && { record: normalizePermission(rawPermissions.record) },
+		...rawPermissions.gql && { gql: normalizeGqlPermission(rawPermissions.gql) }
+	};
+}
+function normalizeActionPermission(permission) {
+	if (isObjectFormat(permission)) {
+		const conditions$1 = permission.conditions;
+		return {
+			conditions: normalizeConditions(isSingleArrayConditionFormat(conditions$1) ? [conditions$1] : conditions$1),
+			permit: permission.permit ? "allow" : "deny",
+			description: permission.description
+		};
+	}
+	if (!Array.isArray(permission)) throw new Error("Invalid permission format");
+	if (isSingleArrayConditionFormat(permission)) {
+		const [op1, operator, op2, permit] = [...permission, true];
+		return {
+			conditions: normalizeConditions([[
+				op1,
+				operator,
+				op2
+			]]),
+			permit: permit ? "allow" : "deny"
+		};
+	}
+	const conditions = [];
+	const conditionArray = permission;
+	let conditionArrayPermit = true;
+	for (const item of conditionArray) {
+		if (typeof item === "boolean") {
+			conditionArrayPermit = item;
+			continue;
+		}
+		conditions.push(item);
+	}
+	return {
+		conditions: normalizeConditions(conditions),
+		permit: conditionArrayPermit ? "allow" : "deny"
+	};
+}
+
+//#endregion
+//#region src/parser/service/tailordb/type-parser.ts
+/**
+* Parse multiple TailorDB types, build relationships, and validate uniqueness.
+* This is the main entry point for parsing TailorDB types.
+*/
+function parseTypes(rawTypes, namespace, typeSourceInfo) {
+	const types$2 = {};
+	for (const [typeName, type] of Object.entries(rawTypes)) types$2[typeName] = parseTailorDBType(type);
+	buildBackwardRelationships(types$2);
+	validatePluralFormUniqueness(types$2, namespace, typeSourceInfo);
+	return types$2;
+}
+/**
+* Parse a TailorDBType into a ParsedTailorDBType.
+*/
+function parseTailorDBType(type) {
+	const metadata = type.metadata;
+	const pluralForm = metadata.settings?.pluralForm || inflection.pluralize(type.name);
+	const fields = {};
+	const forwardRelationships = {};
+	for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
+		const fieldConfig = parseFieldConfig(fieldDef);
+		ensureNoExternalVariablesInFieldScripts(type.name, fieldName, fieldConfig);
+		const parsedField = {
+			name: fieldName,
+			config: fieldConfig
+		};
+		const ref$1 = fieldDef.reference;
+		if (ref$1) {
+			const targetType = ref$1.type?.name;
+			if (targetType) {
+				const forwardName = ref$1.nameMap?.[0] || inflection.camelize(targetType, true);
+				const backwardName = ref$1.nameMap?.[1] || "";
+				const key = ref$1.key || "id";
+				parsedField.relation = {
+					targetType,
+					forwardName,
+					backwardName,
+					key,
+					unique: fieldDef.metadata?.unique ?? false
+				};
+				forwardRelationships[forwardName] = {
+					name: forwardName,
+					targetType,
+					targetField: fieldName,
+					sourceField: key,
+					isArray: false,
+					description: ref$1.type?.metadata?.description || ""
+				};
+			}
+		}
+		fields[fieldName] = parsedField;
+	}
+	return {
+		name: type.name,
+		pluralForm,
+		description: metadata.description,
+		fields,
+		forwardRelationships,
+		backwardRelationships: {},
+		settings: metadata.settings || {},
+		permissions: parsePermissions(metadata.permissions || {}),
+		indexes: metadata.indexes,
+		files: metadata.files
+	};
+}
+/**
+* Build backward relationships between parsed types.
+*/
+function buildBackwardRelationships(types$2) {
+	for (const [typeName, type] of Object.entries(types$2)) for (const [otherTypeName, otherType] of Object.entries(types$2)) for (const [fieldName, field] of Object.entries(otherType.fields)) if (field.relation && field.relation.targetType === typeName) {
+		let backwardName = field.relation.backwardName;
+		if (!backwardName) {
+			const lowerName = inflection.camelize(otherTypeName, true);
+			backwardName = field.relation.unique ? inflection.singularize(lowerName) : inflection.pluralize(lowerName);
+		}
+		type.backwardRelationships[backwardName] = {
+			name: backwardName,
+			targetType: otherTypeName,
+			targetField: fieldName,
+			sourceField: field.relation.key,
+			isArray: !field.relation.unique,
+			description: otherType.description || ""
+		};
+	}
+}
+/**
+* Validate GraphQL query field name uniqueness.
+* Checks for:
+* 1. Each type's singular query name != plural query name
+* 2. No duplicate query names across all types
+*/
+function validatePluralFormUniqueness(types$2, namespace, typeSourceInfo) {
+	const errors = [];
+	for (const [, parsedType] of Object.entries(types$2)) {
+		const singularQuery = inflection.camelize(parsedType.name, true);
+		if (singularQuery === inflection.camelize(parsedType.pluralForm, true)) {
+			const sourceInfo = typeSourceInfo?.[parsedType.name];
+			const location = sourceInfo ? ` (${sourceInfo.filePath})` : "";
+			errors.push(`Type "${parsedType.name}"${location} has identical singular and plural query names "${singularQuery}". Use db.type(["${parsedType.name}", "UniquePluralForm"], {...}) to set a unique pluralForm.`);
+		}
+	}
+	const queryNameToSource = {};
+	for (const parsedType of Object.values(types$2)) {
+		const singularQuery = inflection.camelize(parsedType.name, true);
+		const pluralQuery = inflection.camelize(parsedType.pluralForm, true);
+		if (!queryNameToSource[singularQuery]) queryNameToSource[singularQuery] = [];
+		queryNameToSource[singularQuery].push({
+			typeName: parsedType.name,
+			kind: "singular"
+		});
+		if (singularQuery !== pluralQuery) {
+			if (!queryNameToSource[pluralQuery]) queryNameToSource[pluralQuery] = [];
+			queryNameToSource[pluralQuery].push({
+				typeName: parsedType.name,
+				kind: "plural"
+			});
+		}
+	}
+	const duplicates = Object.entries(queryNameToSource).filter(([, sources]) => sources.length > 1);
+	for (const [queryName, sources] of duplicates) {
+		const sourceList = sources.map((s) => {
+			const sourceInfo = typeSourceInfo?.[s.typeName];
+			const location = sourceInfo ? ` (${sourceInfo.filePath})` : "";
+			return `"${s.typeName}"${location} (${s.kind})`;
+		}).join(", ");
+		errors.push(`GraphQL query field "${queryName}" conflicts between: ${sourceList}`);
+	}
+	if (errors.length > 0) throw new Error(`GraphQL field name conflicts detected in TailorDB service "${namespace}".\n${errors.map((e) => `  - ${e}`).join("\n")}`);
+}
+
 //#endregion
 //#region src/cli/application/tailordb/service.ts
 var TailorDBService = class {
@@ -98173,77 +98379,7 @@ var TailorDBService = class {
 	parseTypes() {
 		const allTypes = {};
 		for (const fileTypes of Object.values(this.rawTypes)) for (const [typeName, type] of Object.entries(fileTypes)) allTypes[typeName] = type;
-		this.types = {};
-		for (const [typeName, type] of Object.entries(allTypes)) this.types[typeName] = this.parseTailorDBType(type);
-		this.buildBackwardRelationships(this.types);
-	}
-	parseTailorDBType(type) {
-		const metadata = type.metadata;
-		const pluralForm = metadata.settings?.pluralForm || inflection.pluralize(type.name);
-		const fields = {};
-		const forwardRelationships = {};
-		for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
-			const fieldConfig = parseFieldConfig(fieldDef);
-			ensureNoExternalVariablesInFieldScripts(type.name, fieldName, fieldConfig);
-			const parsedField = {
-				name: fieldName,
-				config: fieldConfig
-			};
-			const ref$1 = fieldDef.reference;
-			if (ref$1) {
-				const targetType = ref$1.type?.name;
-				if (targetType) {
-					const forwardName = ref$1.nameMap?.[0] || inflection.camelize(targetType, true);
-					const backwardName = ref$1.nameMap?.[1] || "";
-					const key = ref$1.key || "id";
-					parsedField.relation = {
-						targetType,
-						forwardName,
-						backwardName,
-						key,
-						unique: fieldDef.metadata?.unique ?? false
-					};
-					forwardRelationships[forwardName] = {
-						name: forwardName,
-						targetType,
-						targetField: fieldName,
-						sourceField: key,
-						isArray: false,
-						description: ref$1.type?.metadata?.description || ""
-					};
-				}
-			}
-			fields[fieldName] = parsedField;
-		}
-		return {
-			name: type.name,
-			pluralForm,
-			description: metadata.description,
-			fields,
-			forwardRelationships,
-			backwardRelationships: {},
-			settings: metadata.settings || {},
-			permissions: metadata.permissions || {},
-			indexes: metadata.indexes,
-			files: metadata.files
-		};
-	}
-	buildBackwardRelationships(types$2) {
-		for (const [typeName, type] of Object.entries(types$2)) for (const [otherTypeName, otherType] of Object.entries(types$2)) for (const [fieldName, field] of Object.entries(otherType.fields)) if (field.relation && field.relation.targetType === typeName) {
-			let backwardName = field.relation.backwardName;
-			if (!backwardName) {
-				const lowerName = inflection.camelize(otherTypeName, true);
-				backwardName = field.relation.unique ? inflection.singularize(lowerName) : inflection.pluralize(lowerName);
-			}
-			type.backwardRelationships[backwardName] = {
-				name: backwardName,
-				targetType: otherTypeName,
-				targetField: fieldName,
-				sourceField: field.relation.key,
-				isArray: !field.relation.unique,
-				description: otherType.description || ""
-			};
-		}
+		this.types = parseTypes(allTypes, this.namespace, this.typeSourceInfo);
 	}
 };
 
@@ -101875,16 +102011,18 @@ async function confirmOwnerConflict(conflicts, appName, yes) {
 }
 async function confirmUnmanagedResources(resources, appName, yes) {
 	if (resources.length === 0) return;
-	logger.warn("Unmanaged resources detected:");
+	logger.warn("Existing resources not tracked by tailor-sdk were found:");
 	logger.log(`  ${styles.info("Resources")}:`);
 	for (const r$1 of resources) logger.log(`    • ${styles.bold(r$1.resourceType)} ${styles.info(`"${r$1.resourceName}"`)}`);
 	logger.newline();
-	logger.log("  These resources are not managed by any application.");
+	logger.log("  These resources may have been created by older SDK versions, Terraform, or CUE.");
+	logger.log("  To continue, confirm that tailor-sdk should manage them.");
+	logger.log("  If they are managed by another tool (e.g., Terraform), cancel and manage them there instead.");
 	if (yes) {
 		logger.success(`Adding to "${appName}" (--yes flag specified)...`, { mode: "plain" });
 		return;
 	}
-	if (!await logger.prompt(`Add these resources to "${appName}"?`, {
+	if (!await logger.prompt(`Allow tailor-sdk to manage these resources for "${appName}"?`, {
 		type: "confirm",
 		initial: false
 	})) throw new Error(ml`
@@ -103771,7 +103909,7 @@ var DependencyWatcher = class {
 			this.dependencyCache.clear();
 			const impactResult = this.calculateImpact(absolutePath);
 			if (impactResult.affectedGroups.length > 0) {
-				logger.warn("File change detected, restarting watch process...", { mode: "stream" });
+				logger.info("File change detected, restarting watch process...", { mode: "stream" });
 				logger.info(`Changed file: ${absolutePath}`, { mode: "stream" });
 				logger.info(`Affected groups: ${impactResult.affectedGroups.join(", ")}`, { mode: "stream" });
 				if (this.restartCallback) this.restartCallback();
@@ -104071,7 +104209,7 @@ var GenerationManager = class {
 	}
 	async restartWatchProcess() {
 		logger.newline();
-		logger.warn("Restarting watch process to clear module cache...", { mode: "stream" });
+		logger.info("Restarting watch process to clear module cache...", { mode: "stream" });
 		logger.newline();
 		if (this.watcher) await this.watcher.stop();
 		const args = process.argv.slice(2);
@@ -105458,4 +105596,4 @@ const listCommand = defineCommand({
 
 //#endregion
 export { jsonArgs as $, printData as A, loadAccessToken as B, listOAuth2Clients as C, tokenCommand as D, getMachineUserToken as E, generateUserTypes as F, fetchUserInfo as G, readPlatformConfig as H, loadConfig as I, readPackageJson as J, initOAuth2Client as K, apiCall as L, generateCommand as M, apply as N, listCommand$3 as O, applyCommand as P, deploymentArgs as Q, apiCommand as R, listCommand$2 as S, getOAuth2Client as T, writePlatformConfig as U, loadWorkspaceId as V, fetchAll as W, commonArgs as X, PATScope as Y, confirmationArgs as Z, listWorkflowExecutions as _, createCommand as a, remove as b, resumeWorkflow as c, listCommand$1 as d, withCommonArgs as et, listWorkflows as f, getWorkflowExecution as g, executionsCommand as h, deleteWorkspace as i, generate as j, listMachineUsers as k, startCommand as l, getWorkflow as m, listWorkspaces as n, logger as nt, createWorkspace as o, getCommand as p, initOperatorClient as q, deleteCommand as r, resumeCommand as s, listCommand as t, workspaceArgs as tt, startWorkflow as u, show as v, getCommand$1 as w, removeCommand as x, showCommand as y, fetchLatestToken as z };
-//# sourceMappingURL=list-CqNMJdug.mjs.map
+//# sourceMappingURL=list-BSi-MJbT.mjs.map