@tailor-platform/sdk-codemod 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @tailor-platform/sdk-codemod
 
+## 0.8.1
+
+### Patch Changes
+
+- [#2153](https://github.com/tailor-platform/sdk/pull/2153) [`07ac5d0`](https://github.com/tailor-platform/sdk/commit/07ac5d019a14143438bf1072fe2bf7a7e9f6980c) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update dependency @inquirer/prompts to v8.6.0
+
+## 0.8.0
+
+### Minor Changes
+
+- [#2136](https://github.com/tailor-platform/sdk/pull/2136) [`6fba096`](https://github.com/tailor-platform/sdk/commit/6fba09676fc20e08e3325c26c0e72dc9ed4fd8f6) Thanks [@toiroakr](https://github.com/toiroakr)! - `.relation()`'s `toward.type` option is renamed to `toward.table`, since it names a target table rather than a TypeScript/GraphQL type — matching the `db.type()` → `db.table()` rename. The old spelling keeps working as a deprecated alias until v3; `tailor upgrade` offers the `v3/relation-toward-table` codemod to rewrite `toward: { type: ... }` to `toward: { table: ... }` across TypeScript/JavaScript sources. The relation's own `type` (its cardinality, e.g. `"n-1"`) is unchanged.
+
+### Patch Changes
+
+- [#2135](https://github.com/tailor-platform/sdk/pull/2135) [`5b7b676`](https://github.com/tailor-platform/sdk/commit/5b7b676740350dfe35ae479aa73da1f67c4d4f2f) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update dependency politty to v0.11.9
+
 ## 0.7.0
 
 ### Minor Changes

package/dist/codemods/v3/relation-toward-table/scripts/transform.js

@@ -0,0 +1,233 @@
+import { l as stringValue } from "../../../ast-grep-helpers-CXtWn3RB.js";
+import { Lang, parse } from "@ast-grep/napi";
+//#region codemods/v3/relation-toward-table/scripts/transform.ts
+const LEGACY_KEY = "type";
+const NEW_KEY = "table";
+function sourceLang(filePath, source) {
+	const lowerPath = filePath.toLowerCase();
+	if (/\.(?:ts|mts|cts)$/u.test(lowerPath)) return Lang.TypeScript;
+	if (/\.(?:tsx|jsx|js)$/u.test(lowerPath)) return Lang.Tsx;
+	return source.includes("</") ? Lang.Tsx : Lang.TypeScript;
+}
+function relationBindingName(pattern) {
+	if (pattern.kind() !== "object_pattern") return null;
+	for (const child of pattern.children()) {
+		if (child.kind() === "shorthand_property_identifier_pattern" && child.text() === "relation") return child.text();
+		if (child.kind() === "pair_pattern" && stringValue(child.field("key")) === "relation") {
+			const value = child.field("value");
+			return value?.kind() === "identifier" ? value.text() : null;
+		}
+		if (child.kind() === "object_assignment_pattern") {
+			const binding = child.children().find((node) => node.kind() === "shorthand_property_identifier_pattern");
+			if (binding?.text() === "relation") return binding.text();
+		}
+	}
+	return null;
+}
+function relationAliases(root) {
+	const aliases = /* @__PURE__ */ new Set();
+	for (const pattern of root.findAll({ rule: { kind: "object_pattern" } })) {
+		const name = relationBindingName(pattern);
+		if (name) aliases.add(name);
+	}
+	return aliases;
+}
+function isRelationCall(call, aliases) {
+	const callee = call.children()[0];
+	if (!callee) return false;
+	if (callee.kind() === "identifier") return aliases.has(callee.text());
+	if (callee.kind() === "subscript_expression") {
+		const property = literalStringValue(callee.field("index"));
+		return property === null || property === "relation";
+	}
+	if (callee.kind() !== "member_expression") return false;
+	return callee.children().findLast((child) => child.kind() === "property_identifier" || child.kind() === "identifier")?.text() === "relation";
+}
+function callArgument(call) {
+	const args = call.children().find((child) => child.kind() === "arguments");
+	if (!args) return null;
+	const values = args.children().filter((child) => {
+		const kind = child.kind();
+		return kind !== "(" && kind !== ")" && kind !== "," && kind !== "comment";
+	});
+	return values.length === 1 ? values[0] : null;
+}
+function pairKey(pair) {
+	const key = pair.children()[0];
+	return stringValue(key ?? null);
+}
+function pairValue(pair) {
+	const children = pair.children();
+	const colonIndex = children.findIndex((child) => child.kind() === ":");
+	if (colonIndex === -1) return null;
+	return children.slice(colonIndex + 1).find((child) => child.kind() !== "comment") ?? null;
+}
+function objectPair(object, key) {
+	return object.children().find((child) => child.kind() === "pair" && pairKey(child) === key) ?? null;
+}
+function literalStringValue(node) {
+	if (node?.kind() !== "string") return null;
+	return stringValue(node);
+}
+function hasDynamicProperties(object) {
+	return object.children().some((child) => {
+		const kind = child.kind();
+		if (kind === "{" || kind === "}" || kind === "," || kind === "comment") return false;
+		if (kind !== "pair") return true;
+		const keyKind = child.children()[0]?.kind();
+		return keyKind !== "property_identifier" && keyKind !== "string";
+	});
+}
+/**
+* Same as {@link hasDynamicProperties}, but for a `toward` object
+* specifically: a bare `{ type }` shorthand is a safe, rewritable spelling
+* (only the key moves, matching `renameEdit`'s shorthand handling), not a
+* sign of an unsafe/computed key.
+*/
+function hasUnsafeTowardProperties(towardObject) {
+	return towardObject.children().some((child) => {
+		const kind = child.kind();
+		if (kind === "{" || kind === "}" || kind === "," || kind === "comment") return false;
+		if (kind === "shorthand_property_identifier") return false;
+		if (kind !== "pair") return true;
+		const keyKind = child.children()[0]?.kind();
+		return keyKind !== "property_identifier" && keyKind !== "string";
+	});
+}
+function findLegacyEntry(towardObject) {
+	for (const child of towardObject.children()) {
+		if (child.kind() === "shorthand_property_identifier" && child.text() === LEGACY_KEY) return {
+			node: child,
+			shorthand: true
+		};
+		if (child.kind() !== "pair") continue;
+		const key = child.children()[0];
+		if (!key) continue;
+		if (key.kind() !== "property_identifier" && key.kind() !== "string") continue;
+		if (stringValue(key) !== LEGACY_KEY) continue;
+		return {
+			node: key,
+			shorthand: false
+		};
+	}
+	return null;
+}
+function renameEdit(entry) {
+	if (entry.shorthand) return entry.node.replace(`${NEW_KEY}: ${LEGACY_KEY}`);
+	const text = entry.node.text();
+	if (entry.node.kind() !== "string") return entry.node.replace(NEW_KEY);
+	const quote = text.startsWith("'") ? "'" : text.startsWith("`") ? "`" : "\"";
+	return entry.node.replace(`${quote}${NEW_KEY}${quote}`);
+}
+function parseRoot(source, filePath) {
+	try {
+		return parse(sourceLang(filePath, source), source).root();
+	} catch {
+		return null;
+	}
+}
+/**
+* Rename `.relation()`'s `toward.type` option to `toward.table`.
+* @param source - File contents
+* @param filePath - Path to the file being transformed
+* @returns Transformed source, or null when nothing matched
+*/
+function transform(source, filePath = "") {
+	if (!source.includes("relation")) return null;
+	const root = parseRoot(source, filePath);
+	if (!root) return null;
+	const aliases = relationAliases(root);
+	const edits = [];
+	for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isRelationCall(call, aliases)) continue;
+		const config = callArgument(call);
+		if (config?.kind() !== "object") continue;
+		if (hasDynamicProperties(config)) continue;
+		if (!objectPair(config, "type")) continue;
+		const toward = objectPair(config, "toward");
+		if (!toward) continue;
+		const towardConfig = pairValue(toward);
+		if (towardConfig?.kind() !== "object") continue;
+		if (hasUnsafeTowardProperties(towardConfig)) continue;
+		if (objectPair(towardConfig, NEW_KEY)) continue;
+		const entry = findLegacyEntry(towardConfig);
+		if (!entry) continue;
+		edits.push(renameEdit(entry));
+	}
+	return edits.length > 0 ? root.commitEdits(edits) : null;
+}
+function lineOf(node) {
+	return node.range().start.line + 1;
+}
+function excerptOf(node) {
+	return node.text().split("\n", 1)[0].trim();
+}
+/**
+* Report `.relation()` calls this transform cannot safely rewrite: a
+* non-object call argument, a computed/spread key on the config or `toward`
+* object, or a `toward` reached through something other than a literal
+* object (e.g. a shared variable).
+* @param source - File contents
+* @param filePath - Path to the file being reviewed
+* @param relativePath - Repository-relative path reported to the user
+* @returns Findings for occurrences needing a manual rename
+*/
+function reviewFindings(source, filePath, relativePath) {
+	if (!source.includes("relation")) return [];
+	const root = parseRoot(source, filePath);
+	if (!root) return [];
+	const aliases = relationAliases(root);
+	const findings = [];
+	for (const call of root.findAll({ rule: { kind: "call_expression" } })) {
+		if (!isRelationCall(call, aliases)) continue;
+		const config = callArgument(call);
+		if (config?.kind() !== "object") {
+			if (config) findings.push({
+				file: relativePath,
+				line: lineOf(call),
+				message: "This .relation() call's config isn't a literal object; check its toward.type manually.",
+				excerpt: excerptOf(call)
+			});
+			continue;
+		}
+		if (hasDynamicProperties(config)) {
+			findings.push({
+				file: relativePath,
+				line: lineOf(config),
+				message: "A computed/spread key on this .relation() config may hide toward.type.",
+				excerpt: excerptOf(config)
+			});
+			continue;
+		}
+		const toward = objectPair(config, "toward");
+		if (!toward) continue;
+		const towardConfig = pairValue(toward);
+		if (towardConfig?.kind() !== "object") {
+			findings.push({
+				file: relativePath,
+				line: lineOf(toward),
+				message: "This .relation() call's toward isn't a literal object; rename type to table by hand.",
+				excerpt: excerptOf(toward)
+			});
+			continue;
+		}
+		if (hasUnsafeTowardProperties(towardConfig)) {
+			findings.push({
+				file: relativePath,
+				line: lineOf(towardConfig),
+				message: "A computed/spread key on this toward object may hide type.",
+				excerpt: excerptOf(towardConfig)
+			});
+			continue;
+		}
+		if (objectPair(towardConfig, NEW_KEY) && findLegacyEntry(towardConfig)) findings.push({
+			file: relativePath,
+			line: lineOf(towardConfig),
+			message: "This toward object has both table and type; remove the deprecated type by hand instead of automatically renaming it (would produce a duplicate key).",
+			excerpt: excerptOf(towardConfig)
+		});
+	}
+	return findings;
+}
+//#endregion
+export { transform as default, reviewFindings };

package/dist/index.js

@@ -672,7 +672,7 @@ const allCodemods = [
 			after: [
 				"ownerId: db.uuid().relation({",
 				"  type: \"n-1\",",
-				"  toward: { type: user, as: \"user\" },",
+				"  toward: { table: user, as: \"user\" },",
 				"}),"
 			].join("\n")
 		}],
@@ -1079,6 +1079,15 @@ const allCodemods = [
 		prereleaseUntil: V2_NEXT_1,
 		notice: true
 	},
+	{
+		id: "v2/tailordb-timestamps-required",
+		name: "`db.fields.timestamps()`: `updatedAt` becomes required",
+		description: "The `updatedAt` field from `db.fields.timestamps()` changes from optional to required (non-null): it defaults to the current time and keeps refreshing automatically on every update, though a value you provide explicitly is still respected. Applying this change to a table that already has rows with `updatedAt: null` makes `deploy` fail with `field \"updatedAt\" cannot be updated from non-required to required when records with null values exist`. Backfill those rows first, e.g. `UPDATE <table> SET \"updatedAt\" = \"createdAt\" WHERE \"updatedAt\" IS NULL` for each affected table — see [TailorDB migrations](../services/tailordb-migration.md#performance-and-large-tables) for splitting a large backfill across primary-key ranges if a single `UPDATE` times out.",
+		since: "1.0.0",
+		until: "2.0.0",
+		prereleaseUntil: V2_NEXT_2,
+		notice: true
+	},
 	{
 		id: "v2/rename-bin",
 		name: "tailor-sdk binary → tailor",
@@ -1606,6 +1615,38 @@ const allCodemods = [
 			"`setup preview`, or `setup coordinate`, which keeps its name, and leave prose",
 			"that merely mentions the option unchanged unless it documents a command to type."
 		].join("\n")
+	},
+	{
+		id: "v3/relation-toward-table",
+		name: "relation() toward.type → toward.table",
+		description: "Rename the `.relation()` option `toward.type` to `toward.table`, matching the `db.type()` → `db.table()` rename. The relation's own `type` (its cardinality, e.g. `\"n-1\"`) is unchanged — only the target-table reference nested under `toward` moves.",
+		since: "1.0.0",
+		until: "3.0.0",
+		scriptPath: "v3/relation-toward-table/scripts/transform.js",
+		filePatterns: ["**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}"],
+		examples: [{
+			before: [
+				"customerId: db.uuid().relation({",
+				"  type: \"n-1\",",
+				"  toward: { type: customer },",
+				"}),"
+			].join("\n"),
+			after: [
+				"customerId: db.uuid().relation({",
+				"  type: \"n-1\",",
+				"  toward: { table: customer },",
+				"}),"
+			].join("\n")
+		}],
+		prompt: [
+			"In Tailor SDK v3, `.relation()`'s `toward.type` option is renamed to",
+			"`toward.table` (it names a target table, not a TypeScript/GraphQL type).",
+			"Rename any remaining `toward.type` the codemod did not rewrite (e.g. a",
+			"`toward` object reached through a shared variable, spread, or computed",
+			"key) to `toward.table`. Do not touch the relation's own outer `type`",
+			"property, which is the relation's cardinality (e.g. \"n-1\", \"1-1\",",
+			"\"keyOnly\") and keeps its name."
+		].join("\n")
 	}
 ];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/sdk-codemod",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Codemod runner for Tailor Platform SDK upgrades",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,7 @@
     "pathe": "2.0.3",
     "picomatch": "4.0.5",
     "pkg-types": "2.3.1",
-    "politty": "0.11.6",
+    "politty": "0.11.9",
     "semver": "7.8.5",
     "zod": "4.4.3"
   },
@@ -30,11 +30,11 @@
     "@types/picomatch": "4.0.3",
     "@types/semver": "7.8.0",
     "eslint-plugin-zod": "4.9.1",
-    "oxlint": "1.78.0",
+    "oxlint": "1.79.0",
     "oxlint-tsgolint": "7.0.2001",
     "tsdown": "0.22.14",
     "typescript": "6.0.3",
-    "vitest": "4.1.10",
+    "vitest": "4.1.11",
     "@tailor-platform/shared": "^0.0.0"
   },
   "engines": {
@@ -48,7 +48,6 @@
     "knip": "knip",
     "typecheck": "tsc --noEmit",
     "test": "vitest",
-    "prepublish": "pnpm run build",
     "publint": "publint --strict"
   },
   "bin": {