uql-codemod 0.48.2 → 0.49.0

package/dist/tsconfig.js

@@ -1,39 +1,36 @@
 import ts from 'typescript';
-import { applyEdits, removeFromList } from './edits.js';
 import { propertyAssignment, propertyValue } from './syntax.js';
 /** The flags the standard spec has no use for. Their presence is what keeps a project on the old one. */
 const LEGACY_FLAGS = ['experimentalDecorators', 'emitDecoratorMetadata'];
 /**
- * Rewrites a `tsconfig.json` for the standard decorator spec, as text through `ts.parseJsonText` rather than
- * re-serialised: a tsconfig is JSON with comments and someone's formatting, which a rewrite would throw away.
+ * What a `tsconfig.json` needs decided by hand for the standard decorator spec. The file is only read, never
+ * written: its flags are the project's to remove, and a rewrite would have to keep its comments and formatting.
  */
-export function transformTsconfig(fileName, text) {
+export function checkTsconfig(fileName, text) {
     const source = ts.parseJsonText(fileName, text);
     const root = source.statements[0]?.expression;
     if (!root || !ts.isObjectLiteralExpression(root)) {
-        return { text, changed: false, unresolved: [`${fileName}: not an object, so nothing was changed`] };
+        return [`${fileName}: not an object, so nothing was checked`];
     }
-    const edits = [];
     const unresolved = [];
     const compilerOptions = propertyValue(root, 'compilerOptions');
-    if (compilerOptions && ts.isObjectLiteralExpression(compilerOptions)) {
-        const legacy = LEGACY_FLAGS.flatMap((flag) => {
-            const property = propertyAssignment(compilerOptions, flag);
-            return property ? [property] : [];
-        });
-        edits.push(...removeFromList(compilerOptions.properties, legacy, source));
-        // `target` is reported, not rewritten: removing it silently falls back to the compiler default
-        // (`es5` for `tsc`), and choosing a replacement means guessing which era the project targets.
-        const target = propertyValue(compilerOptions, 'target');
-        if (target && ts.isStringLiteral(target) && target.text.toLowerCase() === 'esnext') {
-            unresolved.push(`${fileName}: 'target' is 'esnext', the one target that emits decorator syntax untransformed. ` +
-                'Change it to any dated target, such as `es2024`.');
-        }
+    const options = compilerOptions && ts.isObjectLiteralExpression(compilerOptions) ? compilerOptions : undefined;
+    const legacy = LEGACY_FLAGS.filter((flag) => options && propertyAssignment(options, flag));
+    if (legacy.length) {
+        unresolved.push(`${fileName}: remove ${legacy.map((flag) => `'${flag}'`).join(' and ')} by hand, ` +
+            'since the standard spec is the only one uql-orm supports');
+    }
+    // `target` is only reported: removing it silently falls back to the compiler default (`es5` for `tsc`), and
+    // choosing a replacement means guessing which era the project targets.
+    const target = options && propertyValue(options, 'target');
+    if (target && ts.isStringLiteral(target) && target.text.toLowerCase() === 'esnext') {
+        unresolved.push(`${fileName}: 'target' is 'esnext', the one target that emits decorator syntax untransformed. ` +
+            'Change it to any dated target, such as `es2024`.');
     }
     // A value the file inherits cannot be edited here, and silence would read as "there was none".
-    if (propertyValue(root, 'extends') && !edits.length) {
+    if (propertyValue(root, 'extends') && !legacy.length) {
         unresolved.push(`${fileName}: extends another config, so check the base for 'experimentalDecorators', ` +
             "'emitDecoratorMetadata' and 'target'.");
     }
-    return { text: applyEdits(text, edits), changed: edits.length > 0, unresolved };
+    return unresolved;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "uql-codemod",
   "description": "Upgrade uql-orm across versions that introduce breaking changes",
   "license": "MIT",
-  "version": "0.48.2",
+  "version": "0.49.0",
   "type": "module",
   "engines": {
     "node": ">=22.18"

package/dist/fieldType.d.ts

@@ -1,13 +0,0 @@
-import ts from 'typescript';
-export declare function isBrandedString(type: ts.Type): boolean;
-/**
- * The `type` option reflection supplied for a property of `type`, mirroring `TypeFor` in `uql-orm`, or nothing
- * for a shape a human decides. Only what reflection could produce is read: a `Json<T>` or vector property got
- * `Object`/`Array` from it, so it already declared its `type`.
- */
-export declare function fieldTypeFor(type: ts.Type): string | undefined;
-/**
- * The entity name a relation property points at: `Company` for `Company`, `Company[]`, and
- * `Relation<Company>` alike, since `Relation<T>` is an alias for `T` and erases before this runs.
- */
-export declare function relationTargetFor(type: ts.Type, checker: ts.TypeChecker): string | undefined;

package/dist/fieldType.js

@@ -1,56 +0,0 @@
-import ts from 'typescript';
-/** The string types carrying more than `string`, e.g. `` type UUID = `${string}-${string}` ``, still string columns. */
-const BRANDED_STRING = ts.TypeFlags.TemplateLiteral | ts.TypeFlags.StringMapping;
-export function isBrandedString(type) {
-    return (type.isUnion() ? type.types : [type]).some((t) => !!(t.getFlags() & BRANDED_STRING));
-}
-/**
- * Reads a union by requiring its arms to agree, which is what an `'a' | 'b'` enum or a `T | null` looks
- * like. `undefined` and `null` arms are dropped first: they carry no column type of their own.
- */
-function foldUnion(type, read) {
-    const arms = type.types.filter((arm) => !(arm.getFlags() & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)));
-    const readings = new Set(arms.map(read));
-    return readings.size === 1 ? [...readings][0] : undefined;
-}
-/**
- * The `type` option reflection supplied for a property of `type`, mirroring `TypeFor` in `uql-orm`, or nothing
- * for a shape a human decides. Only what reflection could produce is read: a `Json<T>` or vector property got
- * `Object`/`Array` from it, so it already declared its `type`.
- */
-export function fieldTypeFor(type) {
-    const flags = type.getFlags();
-    if (type.isUnion()) {
-        return foldUnion(type, fieldTypeFor);
-    }
-    if (flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral | BRANDED_STRING))
-        return 'String';
-    if (flags & (ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral))
-        return 'Number';
-    if (flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral))
-        return 'BigInt';
-    if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
-        return 'Boolean';
-    // Matched by declared symbol rather than by the printed type: both of these became generic in the
-    // modern lib, so `Uint8Array` prints as `Uint8Array<ArrayBufferLike>` and never compared equal.
-    const name = type.getSymbol()?.getName();
-    if (name === 'Date')
-        return 'Date';
-    if (name === 'Buffer' || name === 'Uint8Array')
-        return "'blob'";
-    return undefined;
-}
-/**
- * The entity name a relation property points at: `Company` for `Company`, `Company[]`, and
- * `Relation<Company>` alike, since `Relation<T>` is an alias for `T` and erases before this runs.
- */
-export function relationTargetFor(type, checker) {
-    if (type.isUnion()) {
-        return foldUnion(type, (arm) => relationTargetFor(arm, checker));
-    }
-    const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
-    const target = elementType ?? type;
-    const symbol = target.getSymbol();
-    const name = symbol?.getName();
-    return name && name !== '__type' && /^[A-Z][A-Za-z0-9_]*$/.test(name) ? name : undefined;
-}