uql-codemod 0.48.1 → 0.49.0

package/dist/syntax.js

@@ -7,9 +7,91 @@ export function identifierText(node) {
 export function propertyKey(name) {
     return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : undefined;
 }
+export function isNamedProperty(prop) {
+    return ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop);
+}
 /** The property `name` of an object literal, a shorthand included. */
 export function namedProperty(node, name) {
-    return node.properties.find((prop) => (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) && propertyKey(prop.name) === name);
+    return node.properties.find((prop) => isNamedProperty(prop) && propertyKey(prop.name) === name);
+}
+/** The key a property is written under, a shorthand's included; nothing for a spread, a method or a computed key. */
+export function keyOf(prop) {
+    return isNamedProperty(prop) ? propertyKey(prop.name) : undefined;
+}
+/** The options `value` writes: a literal to read and write into, or why it is not one. */
+export function optionsOf(value) {
+    if (!ts.isObjectLiteralExpression(value)) {
+        return { kind: 'opaque', reason: `its options are passed as '${value.getText()}'` };
+    }
+    return value.properties.some(ts.isSpreadAssignment)
+        ? { kind: 'opaque', reason: 'its options object spreads another' }
+        : { kind: 'literal', node: value };
+}
+/**
+ * An object literal's named properties by key, each as its value (a shorthand's value is its name), or `undefined`
+ * where `node` is no literal or one of its properties is spread, computed or a method.
+ */
+export function propertiesByKey(node) {
+    const literal = objectLiteral(node);
+    if (!literal) {
+        return undefined;
+    }
+    const props = new Map();
+    for (const prop of literal.properties) {
+        if (!isNamedProperty(prop)) {
+            return undefined;
+        }
+        const key = propertyKey(prop.name);
+        if (key === undefined) {
+            return undefined;
+        }
+        props.set(key, ts.isShorthandPropertyAssignment(prop) ? prop.name : prop.initializer);
+    }
+    return props;
+}
+/** The root a method chain starts from, and its methods in source order: `f.string().nullable()` is `f` and two. */
+export function chainOf(node) {
+    const methods = [];
+    let root = node;
+    while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression)) {
+        methods.unshift({ call: root, name: root.expression.name.text, receiver: root.expression.expression });
+        root = root.expression.expression;
+    }
+    return { root, methods };
+}
+export function hasModifier(node, kind) {
+    return ts.canHaveModifiers(node) && !!ts.getModifiers(node)?.some((modifier) => modifier.kind === kind);
+}
+/** `preferred`, or it numbered past every name `nodes` mention, so a parameter named so shadows nothing they read. */
+export function freeName(preferred, nodes) {
+    const taken = (name) => nodes.some((node) => mentions(node, name));
+    let name = preferred;
+    for (let n = 2; taken(name); n++) {
+        name = `${preferred}${n}`;
+    }
+    return name;
+}
+/** Whether `node` is an identifier reading `name`, not a member named so. */
+function readsName(node, name) {
+    return (ts.isIdentifier(node) &&
+        node.text === name &&
+        !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node));
+}
+/** Each identifier in `node` naming `name`, in source order, nested functions included, but none a member named so. */
+export function identifierUses(node, name) {
+    const uses = [];
+    const visit = (child) => {
+        if (readsName(child, name)) {
+            uses.push(child);
+        }
+        ts.forEachChild(child, visit);
+    };
+    visit(node);
+    return uses;
+}
+/** Whether `node` reads a binding named `name`, which a callback parameter of that name would shadow: stops at the first. */
+export function mentions(node, name) {
+    return readsName(node, name) || !!ts.forEachChild(node, (child) => mentions(child, name) || undefined);
 }
 /** The property `name` of an object literal that is written with a value. */
 export function propertyAssignment(node, name) {
@@ -22,6 +104,13 @@ export function propertyValue(node, name) {
 export function objectProperties(node) {
     return node && ts.isObjectLiteralExpression(node) ? node.properties.filter(ts.isPropertyAssignment) : [];
 }
+/** The entries of a column list, written as an array or returned by its callback. */
+export function columnListEntries(list) {
+    if (list && ts.isArrowFunction(list) && !ts.isBlock(list.body)) {
+        return arrayElements(list.body);
+    }
+    return arrayElements(list);
+}
 /** The elements of an array literal, or none where `node` is not one. */
 export function arrayElements(node) {
     return node && ts.isArrayLiteralExpression(node) ? node.elements : [];
@@ -30,6 +119,35 @@ export function arrayElements(node) {
 export function objectLiteral(node) {
     return node && ts.isObjectLiteralExpression(node) ? node : undefined;
 }
+const indentUnits = new WeakMap();
+/** Whether `node` starts a line of code whose indent a file's unit is read from: a member, a property, a statement. */
+const startsCodeLine = (node) => ts.isClassElement(node) ||
+    ts.isPropertyAssignment(node) ||
+    ts.isShorthandPropertyAssignment(node) ||
+    ts.isVariableStatement(node) ||
+    ts.isExpressionStatement(node) ||
+    ts.isClassDeclaration(node) ||
+    ts.isFunctionDeclaration(node) ||
+    ts.isImportDeclaration(node);
+/** One level of indentation as the file writes it: the shallowest indent of its code, two spaces where it has none. */
+export function indentUnit(source) {
+    const known = indentUnits.get(source);
+    if (known !== undefined) {
+        return known;
+    }
+    const indents = [];
+    const visit = (node) => {
+        const indent = startsCodeLine(node) ? indentOf(node) : '';
+        if (indent) {
+            indents.push(indent);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    const unit = indents.reduce((shallow, indent) => (indent.length < shallow.length ? indent : shallow), indents[0] ?? '  ');
+    indentUnits.set(source, unit);
+    return unit;
+}
 /** A node's decorators, or none where it is a kind that cannot carry them. */
 export function decoratorsOf(node) {
     return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? []) : [];
@@ -39,3 +157,15 @@ export function decoratorName(node) {
     const { expression } = node;
     return identifierText(ts.isCallExpression(expression) ? expression.expression : expression);
 }
+/** The decorators declaring a field: `@Field`, and `@Id` for the key the class names. */
+export const FIELD_DECORATORS = new Set(['Field', 'Id']);
+/** Where the line holding offset `at` of `text` starts. */
+export function lineStartOf(text, at) {
+    return text.lastIndexOf('\n', at - 1) + 1;
+}
+/** The whitespace the line holding `node` starts with. */
+export function indentOf(node) {
+    const text = node.getSourceFile().text;
+    const line = text.slice(lineStartOf(text, node.getStart()), node.getStart());
+    return line.slice(0, line.length - line.trimStart().length);
+}

package/dist/transform.d.ts

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { type Pass } from './edits.js';
 export type FileResult = {
     readonly fileName: string;
     readonly text: string;
@@ -9,9 +10,17 @@ export type FileResult = {
     readonly notes: readonly string[];
 };
 /**
- * Rewrites one source file for the standard decorator spec. The builder's and querier's methods are known by
- * name, so they are read only in a file importing uql-orm, and `expr` only where it is uql's.
+ * Rewrites one file across every breaking change: the earlier ones off the checker, then column builders and schema
+ * chains off the text those produced, so neither pass edits what the other writes.
  */
 export declare function transformFile(source: ts.SourceFile, checker: ts.TypeChecker, options?: {
     readonly strictNullChecks: boolean;
 }): FileResult;
+/**
+ * The rewrites the checker reads types for, up to the schema entities a class-form registration declares. The
+ * builder's and querier's methods are known by name, so they are read only in a file importing uql-orm, and `expr`
+ * only where it is uql's.
+ */
+export declare function rewriteLegacy(source: ts.SourceFile, checker: ts.TypeChecker, options: {
+    readonly strictNullChecks: boolean;
+}): FileResult & Pass;