@kequtech/tenon-orm 0.1.3 → 0.2.0

package/dist/safeql/composition.js

@@ -1,168 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import ts from 'typescript';
-import { joinSeparator, quote } from '../sql.js';
-import { renderMutation } from './mutations.js';
-import { CompositionError, initializer, literalString, unwrap } from './static.js';
-export { CompositionError } from './static.js';
-/** Recognize Tenon's declarations without claiming another library's SQL tags. */
-const tenonModules = new Map();
-function isTenonModule(filename) {
-    const cached = tenonModules.get(filename);
-    if (cached !== undefined)
-        return cached;
-    let matches = false;
-    if (['query.ts', 'query.d.ts'].includes(basename(filename)) &&
-        ['src', 'dist'].includes(basename(dirname(filename)))) {
-        try {
-            const manifest = JSON.parse(readFileSync(join(dirname(filename), '..', 'package.json'), 'utf8'));
-            matches =
-                typeof manifest === 'object' &&
-                    manifest !== null &&
-                    'name' in manifest &&
-                    manifest.name === '@kequtech/tenon-orm';
-        }
-        catch {
-            // An unrelated or unavailable declaration is not a Tenon export.
-        }
-    }
-    tenonModules.set(filename, matches);
-    return matches;
-}
-export function isExport(node, checker, name) {
-    // Call signatures retain their declaration through local aliases, object properties,
-    // and typeof annotations. Symbol names alone only recognize direct imports.
-    return checker
-        .getTypeAtLocation(node)
-        .getCallSignatures()
-        .some((signature) => {
-        const declaration = signature.declaration;
-        return (declaration &&
-            ts.isFunctionDeclaration(declaration) &&
-            declaration.name?.text === (name === 'sql' ? 'createQuery' : name) &&
-            isTenonModule(declaration.getSourceFile().fileName));
-    });
-}
-export function isFragment(type) {
-    return type.isUnion()
-        ? type.types.some(isFragment)
-        : type.getProperty('__tenonFragment') !== undefined;
-}
-/** Reconstruct only immutable fragments and literal join lists. Never execute application code. */
-export function renderFragment(node, checker, seen = new Set()) {
-    node = unwrap(node);
-    if (seen.has(node))
-        throw new CompositionError('Circular fragment reference.');
-    const visited = new Set(seen).add(node);
-    if (ts.isIdentifier(node)) {
-        const value = initializer(node, checker);
-        if (value)
-            return renderFragment(value, checker, visited);
-    }
-    if (ts.isTaggedTemplateExpression(node) &&
-        ts.isPropertyAccessExpression(node.tag) &&
-        node.tag.name.text === 'fragment' &&
-        isExport(node.tag.expression, checker, 'sql')) {
-        const template = node.template;
-        if (ts.isNoSubstitutionTemplateLiteral(template))
-            return template.text;
-        let text = template.head.text;
-        for (const span of template.templateSpans) {
-            text += renderValue(span.expression, checker, visited) + span.literal.text;
-        }
-        return text;
-    }
-    if (ts.isCallExpression(node)) {
-        for (const kind of ['insertValues', 'assignments']) {
-            if (isExport(node.expression, checker, kind))
-                return renderMutation(kind, node, checker);
-        }
-    }
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        node.expression.name.text === 'join' &&
-        isExport(node.expression.expression, checker, 'sql')) {
-        const [items, separator] = node.arguments;
-        const list = items && unwrap(items);
-        if (!list ||
-            !ts.isArrayLiteralExpression(list) ||
-            !list.elements.length ||
-            !separator ||
-            node.arguments.length !== 2) {
-            throw new CompositionError('sql.join needs a nonempty literal array and a separator for static checking.');
-        }
-        const value = literalString(separator, checker);
-        if (value === undefined) {
-            throw new CompositionError('sql.join separators must be literal strings or const strings.');
-        }
-        let between;
-        try {
-            between = joinSeparator(value);
-        }
-        catch (error) {
-            if (!(error instanceof Error))
-                throw error;
-            throw new CompositionError(error.message);
-        }
-        return list.elements.map((item) => renderFragment(item, checker, visited)).join(between);
-    }
-    if (ts.isCallExpression(node)) {
-        throw new CompositionError(`Function-generated fragments from ${node.expression.getText()}() are not analyzed; the checker does not inspect function bodies.`);
-    }
-    if (ts.isConditionalExpression(node)) {
-        throw new CompositionError('Conditional fragments are not analyzed; the checker does not choose JavaScript branches, even for literal conditions.');
-    }
-    if (ts.isIdentifier(node)) {
-        throw new CompositionError(`Fragment "${node.text}" has no inspectable const initializer; mutable and runtime-supplied fragments are not analyzed.`);
-    }
-    throw new CompositionError('Only constant sql.fragment templates, literal sql.join arrays, and official mutation helpers are supported. Function-generated fragments and conditional SQL structure are not analyzed.');
-}
-export function renderIdentifier(node, checker, seen = new Set()) {
-    node = unwrap(node);
-    if (seen.has(node))
-        throw new CompositionError('Circular identifier reference.');
-    const visited = new Set(seen).add(node);
-    if (ts.isIdentifier(node)) {
-        const value = initializer(node, checker);
-        if (value)
-            return renderIdentifier(value, checker, visited);
-    }
-    if (ts.isCallExpression(node) &&
-        isExport(node.expression, checker, 'identifier') &&
-        node.arguments.length) {
-        return node.arguments
-            .map((part) => {
-            const value = literalString(part, checker);
-            if (value === undefined) {
-                throw new CompositionError('Identifier names must be literal strings or const strings.');
-            }
-            try {
-                return quote(value);
-            }
-            catch (error) {
-                if (!(error instanceof Error))
-                    throw error;
-                throw new CompositionError(error.message);
-            }
-        })
-            .join('.');
-    }
-    throw new CompositionError('The identifier is selected at runtime.');
-}
-export function isIdentifierType(type) {
-    if (type.isUnion())
-        return type.types.some(isIdentifierType);
-    const symbol = type.getSymbol();
-    return (symbol?.getName() === 'Identifier' &&
-        Boolean(symbol.declarations?.some((declaration) => isTenonModule(declaration.getSourceFile().fileName))));
-}
-export function renderValue(node, checker, seen = new Set()) {
-    const type = checker.getTypeAtLocation(node);
-    if (isFragment(type))
-        return renderFragment(node, checker, seen);
-    if (isIdentifierType(type))
-        return renderIdentifier(node, checker, seen);
-    // Match runtime SQL: PostgreSQL infers parameter types from SQL context, never
-    // from JavaScript types. SafeQL numbers these tokens, respecting quotes/comments.
-    return '$N';
-}

package/dist/safeql/eslint.d.ts

@@ -1,2 +0,0 @@
-import type { ESLint } from 'eslint';
-export declare const eslintPlugin: ESLint.Plugin;

package/dist/safeql/eslint.js

@@ -1,50 +0,0 @@
-import ts from 'typescript';
-import { CompositionError, isExport, renderValue } from './composition.js';
-export const eslintPlugin = {
-    rules: {
-        'check-composition': {
-            meta: {
-                type: 'problem',
-                docs: { description: 'Report Tenon queries that cannot be statically checked.' },
-                schema: [],
-            },
-            create(context) {
-                // ESLint leaves parser services untyped; require the TypeScript parser's public services.
-                const { program, esTreeNodeToTSNodeMap: nodes } = context.sourceCode.parserServices;
-                if (!program || !nodes) {
-                    throw new Error('tenon/check-composition requires type-aware TypeScript parsing. Enable parserOptions.project or projectService.');
-                }
-                const checker = program.getTypeChecker();
-                return {
-                    TaggedTemplateExpression(node) {
-                        const template = nodes.get(node);
-                        if (!template ||
-                            !ts.isTaggedTemplateExpression(template) ||
-                            !isExport(template.tag, checker, 'sql'))
-                            return;
-                        if (node.quasi.quasis.some(({ value }) => value.raw !== value.cooked)) {
-                            context.report({
-                                node,
-                                message: new CompositionError('JavaScript escapes in an outer sql template would be checked as different SQL. Use literal newlines and bound string values instead.').message,
-                            });
-                            return;
-                        }
-                        if (ts.isTemplateExpression(template.template)) {
-                            for (const [index, span] of template.template.templateSpans.entries()) {
-                                try {
-                                    renderValue(span.expression, checker);
-                                }
-                                catch (error) {
-                                    if (!(error instanceof CompositionError))
-                                        throw error;
-                                    context.report({ node: node.quasi.expressions[index], message: error.message });
-                                    return;
-                                }
-                            }
-                        }
-                    },
-                };
-            },
-        },
-    },
-};

package/dist/safeql/mutations.d.ts

@@ -1,3 +0,0 @@
-import ts from 'typescript';
-/** Understand the official mutation contract, never the implementation of a JavaScript helper. */
-export declare function renderMutation(kind: 'insertValues' | 'assignments', node: ts.CallExpression, checker: ts.TypeChecker): string;

package/dist/safeql/mutations.js

@@ -1,74 +0,0 @@
-import ts from 'typescript';
-import { assignmentLayout, insertLayout, mutationColumns } from '../mutations.js';
-import { CompositionError, isUndefined, literalString, unwrap } from './static.js';
-const parameter = 0;
-function fields(input) {
-    const node = unwrap(input);
-    if (!ts.isObjectLiteralExpression(node)) {
-        throw new CompositionError('Mutation inputs need inline object literals or an explicit literal column list.');
-    }
-    const result = new Map();
-    for (const property of node.properties) {
-        if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) {
-            throw new CompositionError('Mutation object spreads, accessors, and methods need an explicit literal column list.');
-        }
-        const name = property.name;
-        if (!ts.isIdentifier(name) && !ts.isStringLiteral(name) && !ts.isNumericLiteral(name)) {
-            throw new CompositionError('Mutation keys must be literal names; use an explicit literal column list.');
-        }
-        if (name.text === '__proto__')
-            throw new CompositionError('Prototype-setting object literals are unsupported mutation inputs.');
-        if (result.has(name.text))
-            throw new CompositionError('Duplicate mutation object keys are unsupported.');
-        result.set(name.text, ts.isPropertyAssignment(property) ? property.initializer : property.name);
-    }
-    return result;
-}
-/** Understand the official mutation contract, never the implementation of a JavaScript helper. */
-export function renderMutation(kind, node, checker) {
-    if (node.questionDotToken ||
-        node.arguments.some(ts.isSpreadElement) ||
-        node.arguments.length < 1 ||
-        node.arguments.length > 2) {
-        throw new CompositionError(`sql.${kind} requires an input and an optional literal column list.`);
-    }
-    try {
-        const [argument, selected] = node.arguments;
-        let columns;
-        let rows;
-        if (selected && !isUndefined(selected, checker)) {
-            const list = unwrap(selected);
-            if (!ts.isArrayLiteralExpression(list))
-                throw new CompositionError('Mutation columns must be an inline literal array.');
-            columns = mutationColumns(list.elements.map((item) => {
-                const column = literalString(item, checker);
-                if (column === undefined)
-                    throw new CompositionError('Mutation columns must be literal strings or const strings.');
-                return column;
-            }));
-            // A fixed column contract covers any nonempty batch and every omitted/default cell.
-            // Check all selected columns conservatively; no runtime data or JS types become SQL.
-            rows = [columns.map(() => parameter)];
-        }
-        else {
-            const value = unwrap(argument);
-            const objects = kind === 'insertValues' && ts.isArrayLiteralExpression(value)
-                ? value.elements.map(fields)
-                : [fields(value)];
-            columns = [
-                ...new Set(objects.flatMap((row) => [...row].filter(([, value]) => !isUndefined(value, checker)).map(([key]) => key))),
-            ];
-            rows = objects.map((row) => columns.map((column) => {
-                const cell = row.get(column);
-                return !cell || isUndefined(cell, checker) ? undefined : parameter;
-            }));
-        }
-        const parts = kind === 'insertValues' ? insertLayout(columns, rows) : assignmentLayout(columns, rows[0]);
-        return parts.map((part) => (typeof part === 'string' ? part : '$N')).join('');
-    }
-    catch (error) {
-        if (!(error instanceof Error))
-            throw error;
-        throw new CompositionError(`sql.${kind}: ${error instanceof CompositionError ? error.detail : error.message}`);
-    }
-}

package/dist/safeql/plugin.d.ts

@@ -1,3 +0,0 @@
-import type { SafeQLPlugin } from '@ts-safeql/plugin-utils';
-/** Loaded through the exported SafeQL plugin descriptor. */
-export declare function factory(): SafeQLPlugin;

package/dist/safeql/plugin.js

@@ -1,43 +0,0 @@
-import ts from 'typescript';
-import { CompositionError, isExport, renderValue } from './composition.js';
-/** Loaded through the exported SafeQL plugin descriptor. */
-export function factory() {
-    return {
-        name: 'tenon',
-        connectionDefaults: {
-            inferLiterals: false,
-            overrides: {
-                types: {
-                    int8: 'string',
-                    numeric: 'string',
-                    json: 'unknown',
-                    jsonb: 'unknown',
-                    date: 'Date | number',
-                    timestamp: 'Date | number',
-                    timestamptz: 'Date | number',
-                },
-            },
-        },
-        onTarget({ node, context }) {
-            const template = context.parser.esTreeNodeToTSNodeMap.get(node);
-            if (!ts.isTaggedTemplateExpression(template) ||
-                !isExport(template.tag, context.checker, 'sql'))
-                return false;
-            // The companion ESLint rule reports unsupported forms. Skip their SQL analysis.
-            if (node.quasi.quasis.some(({ value }) => value.raw !== value.cooked))
-                return false;
-            // Defer to SafeQL's configured targets, including per-connection tag selection.
-            return undefined;
-        },
-        onExpression({ context }) {
-            try {
-                return renderValue(context.tsNode, context.checker);
-            }
-            catch (error) {
-                if (!(error instanceof CompositionError))
-                    throw error;
-                return false;
-            }
-        },
-    };
-}

package/dist/safeql/static.d.ts

@@ -1,10 +0,0 @@
-import ts from 'typescript';
-export declare class CompositionError extends Error {
-    readonly detail: string;
-    readonly name = "TenonCompositionError";
-    constructor(detail: string);
-}
-export declare function unwrap(node: ts.Node): ts.Node;
-export declare function initializer(node: ts.Identifier, checker: ts.TypeChecker): ts.Expression | undefined;
-export declare function literalString(node: ts.Node, checker: ts.TypeChecker): string | undefined;
-export declare function isUndefined(node: ts.Node, checker: ts.TypeChecker): boolean;

package/dist/safeql/static.js

@@ -1,59 +0,0 @@
-import ts from 'typescript';
-export class CompositionError extends Error {
-    detail;
-    name = 'TenonCompositionError';
-    constructor(detail) {
-        super(`Tenon cannot statically check this composition: ${detail} Use a static query/fragment, or an explicit lint suppression with database tests for every runtime variant.`);
-        this.detail = detail;
-    }
-}
-export function unwrap(node) {
-    while (ts.isParenthesizedExpression(node) ||
-        ts.isAsExpression(node) ||
-        ts.isSatisfiesExpression(node) ||
-        ts.isNonNullExpression(node) ||
-        ts.isTypeAssertionExpression(node))
-        node = node.expression;
-    return node;
-}
-export function initializer(node, checker) {
-    let symbol = checker.getSymbolAtLocation(node);
-    if (symbol && symbol.flags & ts.SymbolFlags.Alias)
-        symbol = checker.getAliasedSymbol(symbol);
-    const declaration = symbol?.valueDeclaration;
-    return declaration &&
-        ts.isVariableDeclaration(declaration) &&
-        ts.isVariableDeclarationList(declaration.parent) &&
-        declaration.parent.flags & ts.NodeFlags.Const
-        ? declaration.initializer
-        : undefined;
-}
-/** Follow immutable const aliases only. Never inspect functions or evaluate expressions. */
-function constant(node, checker) {
-    const seen = new Set();
-    node = unwrap(node);
-    while (ts.isIdentifier(node)) {
-        if (seen.has(node))
-            throw new CompositionError('Circular const reference.');
-        if (seen.size >= 1000)
-            throw new CompositionError('Const resolution exceeds 1000 references.');
-        seen.add(node);
-        const value = initializer(node, checker);
-        if (!value)
-            break;
-        node = unwrap(value);
-    }
-    return node;
-}
-export function literalString(node, checker) {
-    const value = constant(node, checker);
-    return ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)
-        ? value.text
-        : undefined;
-}
-export function isUndefined(node, checker) {
-    const value = constant(node, checker);
-    return (ts.isIdentifier(value) &&
-        value.text === 'undefined' &&
-        !checker.getSymbolAtLocation(value)?.declarations?.length);
-}

package/dist/safeql.d.ts

@@ -1,6 +0,0 @@
-/** Add to a connection's plugins in normal SafeQL configuration. */
-export declare const safeqlPlugin: {
-    package: string;
-};
-/** Register as `tenon` in ESLint and enable `tenon/check-composition`. */
-export { eslintPlugin } from './safeql/eslint.js';

package/dist/safeql.js

@@ -1,7 +0,0 @@
-import { fileURLToPath } from 'node:url';
-/** Add to a connection's plugins in normal SafeQL configuration. */
-export const safeqlPlugin = {
-    package: fileURLToPath(new URL('./safeql/plugin.js', import.meta.url)),
-};
-/** Register as `tenon` in ESLint and enable `tenon/check-composition`. */
-export { eslintPlugin } from './safeql/eslint.js';