@kequtech/tenon-orm 0.3.1 → 0.4.2

package/dist/check/project.js

@@ -0,0 +1,224 @@
+import { randomUUID } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import ts from 'typescript';
+import { defaultCodecs } from '@kequtech/pgclear';
+export function location(node) {
+    const source = node.getSourceFile();
+    const position = source.getLineAndCharacterOfPosition(node.getStart(source));
+    return {
+        file: resolve(source.fileName),
+        line: position.line + 1,
+        column: position.character + 1,
+    };
+}
+export function symbol(checker, node) {
+    const found = node.parent && ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node
+        ? checker.getShorthandAssignmentValueSymbol(node.parent)
+        : checker.getSymbolAtLocation(node);
+    return found && found.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(found) : found;
+}
+/** Validate modules supplying representation types without selecting unrelated project files. */
+function representationSources(checker, root) {
+    const sources = new Set();
+    const pending = [root];
+    while (pending.length) {
+        const source = pending.pop();
+        if (sources.has(source))
+            continue;
+        sources.add(source);
+        const visit = (node) => {
+            let reference;
+            if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+                reference = node.moduleSpecifier;
+            }
+            else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+                reference = node.argument.literal;
+            }
+            else if (ts.isImportEqualsDeclaration(node) &&
+                ts.isExternalModuleReference(node.moduleReference)) {
+                reference = node.moduleReference.expression;
+            }
+            else if (ts.isCallExpression(node) &&
+                node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+                reference = node.arguments[0];
+            }
+            if (reference && ts.isStringLiteralLike(reference)) {
+                const module = checker.getSymbolAtLocation(reference);
+                for (const declaration of module?.declarations ?? []) {
+                    pending.push(declaration.getSourceFile());
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(source);
+    }
+    return [...sources];
+}
+const representations = [
+    'unknown',
+    'string',
+    'number',
+    'bigint',
+    'boolean',
+    'globalThis.Uint8Array',
+    'globalThis.Date',
+    'import("@kequtech/tenon-orm").TemporalInput',
+    ...['unknown', 'string', 'number', 'bigint', 'boolean', 'globalThis.Uint8Array'].map((type) => `PgArray<${type}>`),
+];
+export function loadProject(options) {
+    const match = options.target?.match(/^(.*):(\d+)$/);
+    const filename = options.target === undefined ? undefined : resolve(match?.[1] ?? options.target);
+    const line = match === null || match === undefined ? undefined : Number(match[2]);
+    if (line !== undefined && (!Number.isSafeInteger(line) || line < 1)) {
+        throw new Error('The query line must be a positive, one-based integer.');
+    }
+    const configPath = options.project === undefined
+        ? ts.findConfigFile(filename ? dirname(filename) : process.cwd(), ts.sys.fileExists)
+        : ts.sys.directoryExists(resolve(options.project))
+            ? resolve(options.project, 'tsconfig.json')
+            : resolve(options.project);
+    if (!configPath)
+        throw new Error('No tsconfig.json found. Pass --project with the project configuration.');
+    const config = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (config.error)
+        throw new Error(ts.flattenDiagnosticMessageText(config.error.messageText, '\n'));
+    const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, dirname(configPath), undefined, configPath);
+    if (parsed.errors.length) {
+        throw new Error(parsed.errors
+            .map((error) => ts.flattenDiagnosticMessageText(error.messageText, '\n'))
+            .join('\n'));
+    }
+    if (!(parsed.options.strictNullChecks ?? parsed.options.strict)) {
+        throw new Error('Query checking requires strictNullChecks in the TypeScript project.');
+    }
+    const custom = Object.entries(options.readTypes ?? {});
+    for (const [oid, type] of custom) {
+        if (!Number.isInteger(Number(oid)) ||
+            Number(oid) < 1 ||
+            Number(oid) > 0xffffffff ||
+            typeof type !== 'string' ||
+            !type.trim()) {
+            throw new Error('readTypes requires PostgreSQL OIDs and nonempty TypeScript type expressions.');
+        }
+    }
+    const expressions = [
+        ...new Set([
+            ...representations,
+            ...(options.codecs ?? defaultCodecs).typescriptTypes(),
+            ...custom.map(([, type]) => type),
+        ]),
+    ];
+    const virtualPath = resolve(dirname(configPath), `.tenon-check-${randomUUID()}.ts`);
+    const virtualSource = [
+        'type PgArray<T> = readonly (T | null | PgArray<T>)[];',
+        ...expressions.map((type, index) => `export type Read${index} = ${type};`),
+        'export type Parameter = import("@kequtech/tenon-orm").Parameter;',
+    ].join('\n');
+    // Emission layout must not constrain the in-memory representation module.
+    const compilerOptions = { ...parsed.options, noEmit: true };
+    delete compilerOptions.rootDir;
+    const host = ts.createCompilerHost(compilerOptions);
+    const readFile = host.readFile.bind(host);
+    const fileExists = host.fileExists.bind(host);
+    host.readFile = (path) => (resolve(path) === virtualPath ? virtualSource : readFile(path));
+    host.fileExists = (path) => resolve(path) === virtualPath || fileExists(path);
+    const program = ts.createProgram({
+        rootNames: [...parsed.fileNames, virtualPath],
+        options: compilerOptions,
+        host,
+        ...(parsed.projectReferences ? { projectReferences: parsed.projectReferences } : {}),
+    });
+    const checker = program.getTypeChecker();
+    const helper = program.getSourceFile(virtualPath);
+    const types = new Map();
+    for (const statement of helper.statements) {
+        if (ts.isTypeAliasDeclaration(statement) && statement.name.text.startsWith('Read')) {
+            types.set(expressions[Number(statement.name.text.slice(4))], checker.getTypeFromTypeNode(statement.type));
+        }
+    }
+    const parameterNode = helper.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.text === 'Parameter');
+    const parameterType = checker.getTypeFromTypeNode(parameterNode.type);
+    const helperErrors = representationSources(checker, helper).flatMap((source) => [
+        ...program.getSyntacticDiagnostics(source),
+        ...program.getSemanticDiagnostics(source),
+    ]);
+    if (helperErrors.length) {
+        throw new Error(`Cannot resolve checker representation types: ${helperErrors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, '\n')).join('\n')}`);
+    }
+    const files = program
+        .getSourceFiles()
+        .filter((source) => !source.isDeclarationFile &&
+        resolve(source.fileName) !== virtualPath &&
+        !program.isSourceFileFromExternalLibrary(source));
+    const selected = filename === undefined
+        ? files
+        : files.filter((source) => resolve(source.fileName) === filename);
+    if (filename !== undefined && !selected.length)
+        throw new Error('The target file is not a source file in this TypeScript project. Check --project and tsconfig inclusion.');
+    const diagnostics = [];
+    for (const error of [...program.getOptionsDiagnostics(), ...program.getGlobalDiagnostics()]) {
+        if (error.category === ts.DiagnosticCategory.Error)
+            diagnostics.push({
+                file: resolve(configPath),
+                line: 1,
+                column: 1,
+                kind: 'mismatch',
+                code: 'typescript-configuration',
+                message: ts.flattenDiagnosticMessageText(error.messageText, '\n'),
+            });
+    }
+    for (const source of selected) {
+        for (const error of [
+            ...program.getSyntacticDiagnostics(source),
+            ...program.getSemanticDiagnostics(source),
+        ]) {
+            if (error.category !== ts.DiagnosticCategory.Error)
+                continue;
+            const position = source.getLineAndCharacterOfPosition(error.start ?? 0);
+            diagnostics.push({
+                file: resolve(source.fileName),
+                line: position.line + 1,
+                column: position.character + 1,
+                kind: 'mismatch',
+                code: 'typescript-error',
+                message: ts.flattenDiagnosticMessageText(error.messageText, '\n'),
+            });
+        }
+    }
+    return {
+        program,
+        checker,
+        types,
+        parameterType,
+        files,
+        selected,
+        line,
+        project: resolve(configPath),
+        diagnostics,
+    };
+}
+/** Resolve actual exported symbols, including aliases and barrel re-exports. */
+export function librarySymbols(project) {
+    const found = new Map();
+    for (const source of project.program.getSourceFiles()) {
+        for (const statement of source.statements) {
+            if (!(ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) ||
+                !statement.moduleSpecifier ||
+                !ts.isStringLiteral(statement.moduleSpecifier))
+                continue;
+            const moduleName = statement.moduleSpecifier.text;
+            if (!['@kequtech/tenon-orm', '@kequtech/pgclear'].includes(moduleName))
+                continue;
+            const module = project.checker.getSymbolAtLocation(statement.moduleSpecifier);
+            if (!module)
+                continue;
+            for (const exported of project.checker.getExportsOfModule(module)) {
+                const target = exported.flags & ts.SymbolFlags.Alias
+                    ? project.checker.getAliasedSymbol(exported)
+                    : exported;
+                found.set(`${moduleName}:${exported.name}`, target);
+            }
+        }
+    }
+    return found;
+}

package/dist/check/source.d.ts

@@ -0,0 +1,51 @@
+import ts from 'typescript';
+import { type Project } from './project.js';
+import type { CheckDiagnostic } from './types.js';
+export declare const variantLimit = 16;
+type QueryNode = ts.TaggedTemplateExpression | ts.CallExpression;
+export interface Binding {
+    readonly node: ts.Expression;
+    readonly type: ts.Type;
+    readonly field?: string;
+}
+export interface QueryVariant {
+    readonly text: string;
+    readonly parameters: readonly Binding[];
+    readonly parameterTypes: readonly number[];
+    readonly uncertainParameters: readonly number[];
+}
+export declare class Unsupported extends Error {
+    readonly node: ts.Node;
+    readonly code: string;
+    constructor(node: ts.Node, code: string, message: string);
+}
+/** A bounded interpreter for SQL structure, never for application values or function bodies. */
+export declare class SourceAnalysis {
+    readonly project: Project;
+    private readonly libraries;
+    readonly issues: CheckDiagnostic[];
+    private readonly immutableArrays;
+    private readonly stableParameters;
+    private readonly unstableConditions;
+    constructor(project: Project, libraries: ReadonlyMap<string, ts.Symbol>);
+    role(input: ts.Expression, depth?: number): string | undefined;
+    query(node: ts.Node): node is QueryNode;
+    discover(source: ts.SourceFile): QueryNode[];
+    private fail;
+    private reference;
+    private text;
+    private array;
+    private closedReference;
+    private combine;
+    private conditional;
+    private template;
+    private mutation;
+    private containsUndefined;
+    private expression;
+    private codecOid;
+    private encoderOid;
+    private hints;
+    recover(node: QueryNode): QueryVariant[];
+    private withHints;
+}
+export type { QueryNode };