@ethlete/query 6.0.0-next.6 → 6.0.0-next.61

package/generators/deprecate-legacy-queries/migration.js

@@ -0,0 +1,85 @@
+import { formatFiles } from '@nx/devkit';
+import { writeFileSync } from 'fs';
+import * as ts from 'typescript';
+import { createMigrationScope } from '../migrate-to-query-v3/migration-scope.js';
+import { addJsDocTag, createSourceFile, legacyQueryDeprecationTag } from '../migrate-to-query-v3/shared.js';
+const CREATOR_FN = 'createLegacyQueryCreator';
+const isMigratableFile = (filePath) => /\.(ts|mts|cts)$/.test(filePath) && !filePath.endsWith('.d.ts');
+const creatorNameOf = (call, sourceFile) => {
+    const [options] = call.arguments;
+    if (!options || !ts.isObjectLiteralExpression(options)) {
+        return undefined;
+    }
+    const property = options.properties.find((candidate) => ts.isPropertyAssignment(candidate) && candidate.name.getText(sourceFile) === 'creator');
+    if (!property || !ts.isIdentifier(property.initializer)) {
+        return undefined;
+    }
+    return property.initializer.text;
+};
+const collectWrappers = (sourceFile) => {
+    const wrappers = [];
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            ts.isIdentifier(node.initializer.expression) &&
+            node.initializer.expression.text === CREATOR_FN) {
+            const statement = node.parent.parent;
+            // A wrapper declared inside a function body has no importable call sites to strike through.
+            if (ts.isVariableStatement(statement) && ts.isSourceFile(statement.parent)) {
+                wrappers.push({ statement, creatorName: creatorNameOf(node.initializer, sourceFile) });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return wrappers;
+};
+export const deprecateLegacyQueries = (options) => {
+    const { tree, scope, scanOnly = false } = options;
+    let deprecatedWrappers = 0;
+    const files = [];
+    scope.visit(tree, (filePath) => {
+        if (!isMigratableFile(filePath))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes(CREATOR_FN))
+            return;
+        const sourceFile = createSourceFile(content, filePath);
+        const wrappers = collectWrappers(sourceFile);
+        let nextContent = content;
+        let tagged = 0;
+        // Back to front, so an insertion never shifts the position the next wrapper was parsed at.
+        for (const wrapper of wrappers.sort((a, b) => b.statement.getStart(sourceFile) - a.statement.getStart(sourceFile))) {
+            const updated = addJsDocTag(nextContent, sourceFile, wrapper.statement, legacyQueryDeprecationTag(wrapper.creatorName));
+            if (updated === null)
+                continue;
+            nextContent = updated;
+            tagged += 1;
+        }
+        if (tagged === 0)
+            return;
+        if (!scanOnly)
+            tree.write(filePath, nextContent);
+        deprecatedWrappers += tagged;
+        files.push(filePath);
+    });
+    return { deprecatedWrappers, touchedFiles: files.length, files };
+};
+export default async function migrate(tree, schema) {
+    console.log('\n🔄 Deprecating legacy query wrappers...');
+    const scope = createMigrationScope(tree, schema);
+    console.log(`   Scope: ${scope.describe()}`);
+    const scanFile = process.env['ETHLETE_SCAN_FILE'];
+    const { deprecatedWrappers, touchedFiles, files } = deprecateLegacyQueries({ tree, scope, scanOnly: !!scanFile });
+    if (scanFile) {
+        writeFileSync(scanFile, JSON.stringify(files.sort()), 'utf8');
+        return;
+    }
+    console.log(`   Tagged ${deprecatedWrappers} wrapper${deprecatedWrappers === 1 ? '' : 's'} in ${touchedFiles} file${touchedFiles === 1 ? '' : 's'}.`);
+    if (!schema.skipFormat) {
+        await formatFiles(tree);
+    }
+    console.log('\n✅ Legacy query wrappers deprecated successfully!');
+}
+//# sourceMappingURL=migration.js.map

package/generators/deprecate-legacy-queries/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "deprecate-legacy-queries",
+  "title": "Deprecate legacy query wrappers",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Nx projects to migrate. Defaults to every project in the workspace.",
+      "alias": "project"
+    },
+    "include": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Path prefixes to migrate, relative to the workspace root (e.g. 'libs/queries'). Unioned with `projects`. Defaults to the whole workspace.",
+      "alias": "includePath"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/generators/generators.json

@@ -5,10 +5,40 @@
       "schema": "./migrate-to-query-v3/schema.json",
       "description": "Migrate from legacy query system to new query system using interop"
     },
+    "migrate-query-client-features": {
+      "factory": "./migrate-query-client-features/migration",
+      "schema": "./migrate-query-client-features/schema.json",
+      "description": "Migrate createQueryClient multiTabSync/persistence options to opt-in features"
+    },
     "prep-for-query-v3": {
       "factory": "./prep-for-query-v3/migration",
       "schema": "./prep-for-query-v3/schema.json",
       "description": "Update code to prepare for migration to query v3"
+    },
+    "deprecate-legacy-queries": {
+      "factory": "./deprecate-legacy-queries/migration",
+      "schema": "./deprecate-legacy-queries/schema.json",
+      "description": "Mark existing createLegacyQueryCreator wrappers as @deprecated so their call sites surface as still on v2"
+    },
+    "migrate-query-opt-in-features": {
+      "factory": "./migrate-query-opt-in-features/migration",
+      "schema": "./migrate-query-opt-in-features/schema.json",
+      "description": "Migrate query clients to the opt-in error pipeline and bearer auth providers to the opt-in multi-tab sync feature"
+    },
+    "migrate-from-ngrx-toolkit": {
+      "factory": "./migrate-from-ngrx-toolkit/migration",
+      "schema": "./migrate-from-ngrx-toolkit/schema.json",
+      "description": "Move @tomtomb/ngrx-toolkit features onto v3 query creators and the @ethlete/query/ngrx-toolkit interop"
+    },
+    "report-legacy-query-apis": {
+      "factory": "./report-legacy-query-apis/migration",
+      "schema": "./report-legacy-query-apis/schema.json",
+      "description": "Write a task to query-v3-migration-tasks.md for every legacy query collection, infinity query, *etQuery template and entity store"
+    },
+    "move-devtools-contract-imports": {
+      "factory": "./move-devtools-contract-imports/migration",
+      "schema": "./move-devtools-contract-imports/schema.json",
+      "description": "Import the devtools contract from @ethlete/query/devtools-contract instead of @ethlete/query"
     }
   }
 }

package/generators/migrate-from-ngrx-toolkit/args-assignability.js

@@ -0,0 +1,140 @@
+import { dirname } from 'node:path';
+import * as ts from 'typescript';
+const TOOLKIT_PROBE = '__EtToolkitArgs';
+const CREATOR_PROBE = '__EtCreatorArgs';
+const PROBE_FILE = '/__et_args_probe__.ts';
+const MAX_DEPTH = 12;
+const PROBE_SOURCE = `
+import type { ${TOOLKIT_PROBE} as ToolkitArgs } from '__toolkit__';
+import type { ${CREATOR_PROBE} as CreatorArgs } from '__creator__';
+
+type OptionalNullAsUndefined<T> = {
+  [K in keyof T]: undefined extends T[K] ? OptionalNullAsUndefined<Exclude<T[K], null>> : OptionalNullAsUndefined<T[K]>;
+};
+
+export type ToolkitSide = OptionalNullAsUndefined<{
+  [K in keyof ToolkitArgs as K extends 'params' ? 'queryParams' : K extends 'body' ? K : never]: ToolkitArgs[K];
+}>;
+export type CreatorSide = OptionalNullAsUndefined<{
+  [K in keyof CreatorArgs as K extends 'queryParams' | 'body' ? K : never]: CreatorArgs[K];
+}>;
+`;
+const COMPILER_OPTIONS = {
+    strict: true,
+    noEmit: true,
+    skipLibCheck: true,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    lib: ['lib.es2022.d.ts'],
+    types: [],
+};
+const toTreePath = (fileName) => fileName.replace(/^\//, '');
+const containsAny = (checker, type, seen, depth) => {
+    if (type.flags & ts.TypeFlags.Any)
+        return true;
+    if (seen.has(type) || depth > MAX_DEPTH)
+        return false;
+    seen.add(type);
+    if (type.isUnionOrIntersection())
+        return type.types.some((part) => containsAny(checker, part, seen, depth + 1));
+    if (!(type.flags & ts.TypeFlags.Object))
+        return false;
+    const typeArguments = type.objectFlags & ts.ObjectFlags.Reference
+        ? checker.getTypeArguments(type)
+        : [];
+    return (typeArguments.some((argument) => containsAny(checker, argument, seen, depth + 1)) ||
+        checker
+            .getPropertiesOfType(type)
+            .some((property) => containsAny(checker, checker.getTypeOfSymbol(property), seen, depth + 1)));
+};
+const isRecord = (checker, type) => (type.isIntersection() ? type.types : [type]).every((part) => !!(part.flags & ts.TypeFlags.Object)) &&
+    !checker.isArrayType(type) &&
+    !checker.isTupleType(type) &&
+    checker.getSignaturesOfType(type, ts.SignatureKind.Call).length === 0;
+const hasEveryKey = (checker, source, target, seen, depth) => {
+    const from = checker.getNonNullableType(source);
+    const to = checker.getNonNullableType(target);
+    if (seen.has(from) || depth > MAX_DEPTH || !isRecord(checker, from) || !isRecord(checker, to))
+        return true;
+    seen.add(from);
+    return checker.getPropertiesOfType(from).every((property) => {
+        const counterpart = checker.getPropertyOfType(to, property.name);
+        return (!!counterpart &&
+            hasEveryKey(checker, checker.getTypeOfSymbol(property), checker.getTypeOfSymbol(counterpart), seen, depth + 1));
+    });
+};
+export const toolkitArgsFitCreator = (tree, graph, toolkit, creator) => {
+    if (toolkit.file === creator.file)
+        return false;
+    const appended = new Map([
+        [toolkit.file, `\nexport type ${TOOLKIT_PROBE} = ${toolkit.typeText ?? '{}'};\n`],
+        [creator.file, `\nexport type ${CREATOR_PROBE} = ${creator.typeText ?? '{}'};\n`],
+    ]);
+    const libDirectory = dirname(ts.getDefaultLibFilePath(COMPILER_OPTIONS));
+    const readFile = (fileName) => {
+        if (fileName === PROBE_FILE)
+            return PROBE_SOURCE;
+        if (fileName.startsWith(libDirectory))
+            return ts.sys.readFile(fileName);
+        const path = toTreePath(fileName);
+        const content = tree.read(path, 'utf-8');
+        return content === null ? undefined : content + (appended.get(path) ?? '');
+    };
+    const fileExists = (fileName) => fileName === PROBE_FILE ||
+        (fileName.startsWith(libDirectory) ? ts.sys.fileExists(fileName) : tree.isFile(toTreePath(fileName)));
+    const resolutionHost = {
+        fileExists,
+        readFile,
+        directoryExists: (name) => tree.exists(toTreePath(name)) && !tree.isFile(toTreePath(name)),
+        getCurrentDirectory: () => '/',
+    };
+    const resolveOne = (name, containingFile) => {
+        const workspaceFile = containingFile === PROBE_FILE
+            ? name === '__toolkit__'
+                ? toolkit.file
+                : name === '__creator__'
+                    ? creator.file
+                    : null
+            : graph.resolveFile(toTreePath(containingFile), name);
+        if (workspaceFile)
+            return { resolvedFileName: `/${workspaceFile}`, extension: ts.Extension.Ts };
+        return ts.resolveModuleName(name, containingFile, COMPILER_OPTIONS, resolutionHost).resolvedModule;
+    };
+    const host = {
+        ...resolutionHost,
+        getSourceFile: (fileName, languageVersion) => {
+            const text = readFile(fileName);
+            return text === undefined ? undefined : ts.createSourceFile(fileName, text, languageVersion, true);
+        },
+        getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+        writeFile: () => undefined,
+        getCanonicalFileName: (fileName) => fileName,
+        useCaseSensitiveFileNames: () => true,
+        getNewLine: () => '\n',
+        resolveModuleNameLiterals: (literals, containingFile) => literals.map((literal) => ({ resolvedModule: resolveOne(literal.text, containingFile) })),
+    };
+    const program = ts.createProgram({ rootNames: [PROBE_FILE], options: COMPILER_OPTIONS, host });
+    const checker = program.getTypeChecker();
+    const probe = program.getSourceFile(PROBE_FILE);
+    const exportsOf = probe ? checker.getSymbolAtLocation(probe) : undefined;
+    const typeOf = (name) => {
+        const symbol = exportsOf ? checker.getExportsOfModule(exportsOf).find((each) => each.name === name) : undefined;
+        return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+    };
+    const toolkitSide = typeOf('ToolkitSide');
+    const creatorSide = typeOf('CreatorSide');
+    if (!toolkitSide || !creatorSide)
+        return false;
+    if (containsAny(checker, toolkitSide, new Set(), 0) || containsAny(checker, creatorSide, new Set(), 0))
+        return false;
+    const keys = (type) => checker
+        .getPropertiesOfType(type)
+        .map((property) => property.name)
+        .sort()
+        .join(',');
+    return (keys(toolkitSide) === keys(creatorSide) &&
+        checker.isTypeAssignableTo(toolkitSide, creatorSide) &&
+        hasEveryKey(checker, toolkitSide, creatorSide, new Set(), 0));
+};
+//# sourceMappingURL=args-assignability.js.map