@checkdigit/eslint-plugin 7.17.1 → 7.18.0-PR.143-8290

package/dist-types/athena/api-locator.d.ts

@@ -0,0 +1,2 @@
+import { type ApiSchemas } from '../openapi/generate-schema.ts';
+export declare function locateApi(serviceName: string): ApiSchemas[];

package/dist-types/athena/api-matcher.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaObject } from 'ajv/dist/2020';
+import type { ApiSchemas, OperationSchemas } from '../openapi/generate-schema';
+export interface OperationToMatch {
+    path: string;
+    method: string;
+    operationSchemas: OperationSchemas;
+}
+export interface MatchedOperation {
+    path: string;
+    method: string;
+    request: SchemaObject;
+    response: SchemaObject;
+}
+export declare function matchApi(selectAST: object, tableAST: object, apiSchemas: ApiSchemas[]): MatchedOperation[] | undefined;

package/dist-types/athena/athena.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const ruleId = "athena";
+declare const SYNTEXT_ERROR = "SyntextError";
+declare const ATHENA_ERROR = "AthenaError";
+declare const rule: ESLintUtils.RuleModule<typeof SYNTEXT_ERROR | typeof ATHENA_ERROR>;
+export default rule;

package/dist-types/athena/column.d.ts

@@ -0,0 +1 @@
+export type { ResolvedColumn } from './context';

package/dist-types/athena/context.d.ts

@@ -0,0 +1,21 @@
+import type { OpenAPIV3_1 as v3 } from 'openapi-types';
+import type { ApiSchemas } from '../openapi/generate-schema';
+import type { MatchedOperation } from './api-matcher';
+export interface ResolvedColumn {
+    name: string;
+    schema: v3.SchemaObject;
+    ast?: object;
+}
+export interface ResolvedTable {
+    name?: string;
+    columns: Map<string, ResolvedColumn[]>;
+    apiOperation?: MatchedOperation[];
+}
+export interface VisitContext {
+    tables: Map<string, ResolvedTable[]>;
+    aliases: Map<string, string>;
+    apiSchemas: Map<string, ApiSchemas[]>;
+    parent?: VisitContext;
+}
+export declare function createRootContext(): VisitContext;
+export declare function createChildContext(parent: VisitContext): VisitContext;

package/dist-types/athena/index.d.ts

@@ -0,0 +1,8 @@
+import type { OpenAPIV3_1 as v3 } from 'openapi-types';
+export interface ServiceEndpoint {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    requestBody?: v3.SchemaObject;
+    responses: Record<string, v3.SchemaObject>;
+}
+export type Service = Record<string, ServiceEndpoint>;

package/dist-types/athena/service-table.d.ts

@@ -0,0 +1,8 @@
+import type { MatchedOperation } from './api-matcher';
+import type { ResolvedTable } from './context';
+/**
+ * Create one ResolvedTable per matched API operation.
+ * Multiple operations may match (e.g. GET + POST for the same service), so the
+ * caller receives an array and stores all of them under the same table name.
+ */
+export declare function buildServiceTables(tableName: string, operations: MatchedOperation[]): ResolvedTable[];

package/dist-types/athena/types.d.ts

@@ -0,0 +1,474 @@
+export interface With {
+    name: {
+        value: string;
+    };
+    stmt: {
+        _parentheses?: boolean;
+        tableList: string[];
+        columnList: string[];
+        ast: Select;
+    };
+    columns?: any[];
+}
+interface Location {
+    line: number;
+    column: number;
+    offset: number;
+}
+interface LocationRange {
+    start: Location;
+    end: Location;
+}
+export type WhilteListCheckMode = 'table' | 'column';
+export interface ParseOptions {
+    includeLocations?: boolean;
+}
+export interface Option {
+    database?: string;
+    type?: string;
+    trimQuery?: boolean;
+    parseOptions?: ParseOptions;
+}
+export interface TableColumnAst {
+    tableList: string[];
+    columnList: string[];
+    ast: AST[] | AST;
+    loc?: LocationRange;
+}
+export interface BaseFrom {
+    db: string | null;
+    table: string;
+    as: string | null;
+    schema?: string;
+    loc?: LocationRange;
+}
+export interface Join extends BaseFrom {
+    join: 'INNER JOIN' | 'LEFT JOIN' | 'RIGHT JOIN';
+    using?: string[];
+    on?: Binary;
+}
+export interface TableExpr {
+    expr: {
+        ast: Select;
+    };
+    as?: string | null;
+    parentheses: boolean | {
+        length: number;
+    };
+}
+export interface Dual {
+    type: 'dual';
+    loc?: LocationRange;
+}
+export type From = BaseFrom | Join | TableExpr | Dual;
+export interface LimitValue {
+    type: string;
+    value: number;
+    loc?: LocationRange;
+}
+export interface Limit {
+    seperator: string;
+    value: LimitValue[];
+    loc?: LocationRange;
+}
+export interface OrderBy {
+    type: 'ASC' | 'DESC';
+    expr: any;
+    loc?: LocationRange;
+}
+export interface ValueExpr<T = string | number | boolean> {
+    type: 'backticks_quote_string' | 'string' | 'regex_string' | 'hex_string' | 'full_hex_string' | 'natural_string' | 'bit_string' | 'double_quote_string' | 'single_quote_string' | 'boolean' | 'bool' | 'null' | 'star' | 'param' | 'origin' | 'date' | 'datetime' | 'default' | 'time' | 'timestamp' | 'var_string';
+    value: T;
+}
+export interface ColumnRefItem {
+    type: 'column_ref';
+    table: string | null;
+    column: string | {
+        expr: ValueExpr;
+    };
+    options?: ExprList;
+    loc?: LocationRange;
+}
+export interface ColumnRefExpr {
+    type: 'expr';
+    expr: ColumnRefItem;
+    as: string | null;
+}
+export type ColumnRef = ColumnRefItem | ColumnRefExpr;
+export interface SetList {
+    column: string;
+    value: any;
+    table: string | null;
+    loc?: LocationRange;
+}
+export interface InsertReplaceValue {
+    type: 'expr_list';
+    value: any[];
+    loc?: LocationRange;
+}
+export interface Star {
+    type: 'star';
+    value: '*' | '';
+    loc?: LocationRange;
+}
+export interface Case {
+    type: 'case';
+    expr: null;
+    args: ({
+        cond: Binary;
+        result: ExpressionValue;
+        type: 'when';
+    } | {
+        result: ExpressionValue;
+        type: 'else';
+    })[];
+}
+export interface Cast {
+    type: 'cast';
+    keyword: 'cast';
+    expr: ExpressionValue;
+    symbol: 'as';
+    target: {
+        dataType: string;
+        suffix: unknown[];
+    };
+}
+export interface AggrFunc {
+    type: 'aggr_func';
+    name: string;
+    args: {
+        expr: ExpressionValue;
+        distinct: 'DISTINCT' | null;
+        orderby: OrderBy[] | null;
+        parentheses?: boolean;
+    };
+    loc?: LocationRange;
+}
+export interface FunctionName {
+    schema?: {
+        value: string;
+        type: string;
+    };
+    name: ValueExpr<string>[];
+}
+export interface Function {
+    type: 'function';
+    name: FunctionName;
+    args?: ExprList;
+    suffix?: any;
+    loc?: LocationRange;
+}
+export interface Column {
+    expr: ExpressionValue;
+    as: ValueExpr<string> | string | null;
+    type?: string;
+    loc?: LocationRange;
+}
+export interface Interval {
+    type: 'interval';
+    unit: string;
+    expr: ValueExpr & {
+        loc?: LocationRange;
+    };
+}
+export interface Param {
+    type: 'param';
+    value: string;
+    loc?: LocationRange;
+}
+export interface Value {
+    type: string;
+    value: any;
+    loc?: LocationRange;
+}
+export interface Binary {
+    type: 'binary_expr';
+    operator: string;
+    left: ExpressionValue | ExprList;
+    right: ExpressionValue | ExprList;
+    loc?: LocationRange;
+    parentheses?: boolean;
+}
+export type Expr = Binary;
+export type ExpressionValue = ColumnRef | Param | Function | Case | AggrFunc | Value | Binary | Cast | Interval;
+export interface ExprList {
+    type: 'expr_list';
+    value: ExpressionValue[];
+    loc?: LocationRange;
+    parentheses?: boolean;
+    separator?: string;
+}
+export type PartitionBy = {
+    type: 'expr';
+    expr: ColumnRef[];
+}[];
+export interface WindowSpec {
+    name: null;
+    partitionby: PartitionBy;
+    orderby: OrderBy[] | null;
+    window_frame_clause: string | null;
+}
+export type AsWindowSpec = string | {
+    window_specification: WindowSpec;
+    parentheses: boolean;
+};
+export interface NamedWindowExpr {
+    name: string;
+    as_window_specification: AsWindowSpec;
+}
+export interface WindowExpr {
+    keyword: 'window';
+    type: 'window';
+    expr: NamedWindowExpr[];
+}
+export interface Select {
+    with: With[] | null;
+    type: 'select';
+    options: any[] | null;
+    distinct: 'DISTINCT' | null;
+    columns: any[] | Column[];
+    from: From[] | TableExpr | null;
+    where: Binary | Function | null;
+    groupby: {
+        columns: ColumnRef[] | null;
+        modifiers: ValueExpr<string>[];
+    };
+    having: any[] | null;
+    orderby: OrderBy[] | null;
+    limit: Limit | null;
+    window?: WindowExpr;
+    qualify?: any[] | null;
+    _orderby?: OrderBy[] | null;
+    _limit?: Limit | null;
+    parentheses_symbol?: boolean;
+    _parentheses?: boolean;
+    loc?: LocationRange;
+    _next?: Select;
+    set_op?: string;
+}
+export interface Insert_Replace {
+    type: 'replace' | 'insert';
+    table: any;
+    columns: string[] | null;
+    values: InsertReplaceValue[] | Select;
+    partition: any[];
+    prefix: string;
+    on_duplicate_update: {
+        keyword: 'on duplicate key update';
+        set: SetList[];
+    };
+    loc?: LocationRange;
+}
+export interface Update {
+    type: 'update';
+    db: string | null;
+    table: (From | Dual)[] | null;
+    set: SetList[];
+    where: Binary | Function | null;
+    loc?: LocationRange;
+}
+export interface Delete {
+    type: 'delete';
+    table: any;
+    from: (From | Dual)[];
+    where: Binary | Function | null;
+    loc?: LocationRange;
+}
+export interface Alter {
+    type: 'alter';
+    table: From[];
+    expr: any;
+    loc?: LocationRange;
+}
+export interface Use {
+    type: 'use';
+    db: string;
+    loc?: LocationRange;
+}
+type KW_UNSIGNED = 'UNSIGNED';
+type KW_ZEROFILL = 'ZEROFILL';
+type Timezone = ['WITHOUT' | 'WITH', 'TIME', 'ZONE'];
+interface KeywordComment {
+    type: 'comment';
+    keyword: 'comment';
+    symbol?: '=';
+    value: string;
+}
+interface CollateExpr {
+    type: 'collate';
+    symbol?: '=';
+    value: string;
+}
+interface DataType {
+    dataType: string;
+    length?: number;
+    parentheses?: true;
+    suffix?: Timezone | (KW_UNSIGNED | KW_ZEROFILL)[];
+    array?: 'one' | 'two';
+}
+interface LiteralNotNull {
+    type: 'not null';
+    value: 'not null';
+}
+interface LiteralNull {
+    type: 'null';
+    value: null;
+}
+type LiteralNumeric = number | {
+    type: 'bigint';
+    value: string;
+};
+interface ColumnConstraint {
+    default_val: {
+        type: 'default';
+        value: any;
+    };
+    nullable: LiteralNotNull | LiteralNull;
+}
+interface ColumnDefinitionOptList {
+    nullable?: ColumnConstraint['nullable'];
+    default_val?: ColumnConstraint['default_val'];
+    auto_increment?: 'auto_increment';
+    unique?: 'unique' | 'unique key';
+    primary?: 'key' | 'primary key';
+    comment?: KeywordComment;
+    collate?: {
+        collate: CollateExpr;
+    };
+    column_format?: {
+        column_format: any;
+    };
+    storage?: {
+        storage: any;
+    };
+    reference_definition?: {
+        reference_definition: any;
+    };
+    character_set?: {
+        type: 'CHARACTER SET';
+        value: string;
+        symbol?: '=';
+    };
+}
+type CreateColumnDefinition = {
+    column: ColumnRef;
+    definition: DataType;
+    resource: 'column';
+} & ColumnDefinitionOptList;
+interface IndexType {
+    keyword: 'using';
+    type: 'btree' | 'hash' | 'gist' | 'gin';
+}
+interface IndexOption {
+    type: 'key_block_size';
+    symbol?: '=';
+    expr: LiteralNumeric;
+}
+interface CreateIndexDefinition {
+    index?: string;
+    definition: ColumnRef[];
+    keyword: 'index' | 'key';
+    index_type?: IndexType;
+    resource: 'index';
+    index_options?: IndexOption[];
+}
+interface CreateFulltextSpatialIndexDefinition {
+    index?: string;
+    definition: ColumnRef[];
+    keyword?: 'fulltext' | 'spatial' | 'fulltext key' | 'spatial key' | 'fulltext index' | 'spatial index';
+    index_options?: IndexOption[];
+    resource: 'index';
+}
+interface ConstraintName {
+    keyword: 'constraint';
+    constraint: string;
+}
+interface CreateConstraintPrimary {
+    constraint?: ConstraintName['constraint'];
+    definition: ColumnRef[];
+    constraint_type: 'primary key';
+    keyword?: ConstraintName['keyword'];
+    index_type?: IndexType;
+    resource: 'constraint';
+    index_options?: IndexOption[];
+}
+interface CreateConstraintUnique {
+    constraint?: ConstraintName['constraint'];
+    definition: ColumnRef[];
+    constraint_type: 'unique key' | 'unique' | 'unique index';
+    keyword?: ConstraintName['keyword'];
+    index_type?: IndexType;
+    index?: string;
+    resource: 'constraint';
+    index_options?: IndexOption[];
+}
+interface CreateConstraintForeign {
+    constraint?: ConstraintName['constraint'];
+    definition: ColumnRef[];
+    constraint_type: 'FOREIGN KEY';
+    keyword?: ConstraintName['keyword'];
+    index?: string;
+    resource: 'constraint';
+    reference_definition?: any;
+}
+interface CreateConstraintCheck {
+    constraint?: ConstraintName['constraint'];
+    definition: any[];
+    constraint_type: 'check';
+    keyword?: ConstraintName['keyword'];
+    resource: 'constraint';
+}
+type CreateConstraintDefinition = CreateConstraintPrimary | CreateConstraintUnique | CreateConstraintForeign | CreateConstraintCheck;
+type CreateDefinition = CreateColumnDefinition | CreateIndexDefinition | CreateFulltextSpatialIndexDefinition | CreateConstraintDefinition;
+export interface Create {
+    type: 'create';
+    keyword: 'table' | 'index' | 'database';
+    temporary?: 'temporary' | null;
+    table?: {
+        db: string;
+        table: string;
+    }[];
+    if_not_exists?: 'if not exists' | null;
+    like?: {
+        type: 'like';
+        table: string;
+        parentheses?: boolean;
+    } | null;
+    ignore_replace?: 'ignore' | 'replace' | null;
+    as?: string | null;
+    query_expr?: any | null;
+    create_definitions?: CreateDefinition[] | null;
+    table_options?: any[] | null;
+    index_using?: {
+        keyword: 'using';
+        type: 'btree' | 'hash';
+    } | null;
+    index?: string | null;
+    on_kw?: 'on' | null;
+    index_columns?: any[] | null;
+    index_type?: 'unique' | 'fulltext' | 'spatial' | null;
+    index_options?: any[] | null;
+    algorithm_option?: {
+        type: 'alter';
+        keyword: 'algorithm';
+        resource: 'algorithm';
+        symbol: '=' | null;
+        algorithm: 'default' | 'instant' | 'inplace' | 'copy';
+    } | null;
+    lock_option?: {
+        type: 'alter';
+        keyword: 'lock';
+        resource: 'lock';
+        symbol: '=' | null;
+        lock: 'default' | 'none' | 'shared' | 'exclusive';
+    } | null;
+    database?: string;
+    loc?: LocationRange;
+}
+export interface Drop {
+    type: 'drop';
+    keyword: string;
+    name: any[];
+}
+export type AST = Use | Select | Insert_Replace | Update | Delete | Alter | Create | Drop;
+export {};

package/dist-types/athena/visitor.d.ts

@@ -0,0 +1,63 @@
+import type { AggrFunc, BaseFrom, Binary, Case, Cast, Column, ColumnRefItem, Dual, ExpressionValue, ExprList, Function, Join, Select, TableExpr, With } from './types';
+export interface UnnestFrom {
+    type: 'unnest';
+    expr: ColumnRefItem;
+    parentheses: boolean;
+    as: {
+        type: 'function';
+        name: {
+            name: {
+                type: string;
+                value: string;
+            }[];
+        };
+        args: ExprList;
+    } | null;
+}
+export interface ColumnRefWithIndex extends ColumnRefItem {
+    array_index: {
+        brackets: true;
+        index: {
+            type: string;
+            value: unknown;
+        };
+    }[];
+}
+export interface VisitorMap {
+    visitSelect?(node: Select): void;
+    visitWith?(node: With): void;
+    visitBaseFrom?(node: BaseFrom): void;
+    visitJoin?(node: Join): void;
+    visitTableExpr?(node: TableExpr): void;
+    visitUnnest?(node: UnnestFrom): void;
+    visitColumn?(node: Column): void;
+    visitColumnRef?(node: ColumnRefItem): void;
+    visitFunction?(node: Function): void;
+    visitBinary?(node: Binary): void;
+    visitAggrFunc?(node: AggrFunc): void;
+    visitCast?(node: Cast): void;
+    visitCase?(node: Case): void;
+    visitExprList?(node: ExprList): void;
+    visitValue?(node: ExpressionValue): void;
+}
+export declare function isUnnestFrom(node: unknown): node is UnnestFrom;
+export declare function isDual(node: unknown): node is Dual;
+export declare function isTableExpr(node: unknown): node is TableExpr;
+export declare function isJoin(node: unknown): node is Join;
+export declare function isBaseFrom(node: unknown): node is BaseFrom;
+export declare function hasArrayIndex(node: ColumnRefItem): node is ColumnRefWithIndex;
+export declare function walk(node: unknown, visitor: VisitorMap): void;
+/** Collect all column_ref nodes within an expression subtree. */
+export declare function extractColumnRefs(expr: unknown): ColumnRefItem[];
+/** Return the path string from the first json_extract_scalar / json_extract call found. */
+export declare function extractJsonExtractPath(expr: unknown): string | undefined;
+export interface JsonExtractCall {
+    ref: ColumnRefItem;
+    path: string;
+}
+/** Collect ALL json_extract / json_extract_scalar calls as (source column_ref, path) pairs. */
+export declare function extractJsonExtractCalls(expr: unknown): JsonExtractCall[];
+/** Return the JSONPath-style string from a bracket accessor (col['key']), or undefined. */
+export declare function extractBracketAccessorPath(expr: unknown): string | undefined;
+/** Return true if the expression tree contains any function or aggregate call. */
+export declare function hasFunctionCalls(expr: unknown): boolean;

package/dist-types/no-status-code-assert.d.ts

@@ -1,4 +1,4 @@
-import { TSESLint } from '@typescript-eslint/utils';
+import { type TSESLint } from '@typescript-eslint/utils';
 export declare const ruleId = "no-status-code-assert";
 declare const NO_STATUS_CODE_ASSERT = "NO_STATUS_CODE_ASSERT";
 declare const rule: TSESLint.RuleModule<typeof NO_STATUS_CODE_ASSERT>;

package/dist-types/openapi/deref-schema.d.ts

@@ -0,0 +1 @@
+export declare function derefSchema(schemaFileName: string): Promise<void>;

package/dist-types/openapi/generate-schema.d.ts

@@ -0,0 +1,33 @@
+import type { SchemaObject } from 'ajv/dist/2020';
+export declare const commandName = "generate-schema";
+export { generateSchemasForService } from './service-schema-generator.ts';
+declare const ALL_OPERATION_METHODS: readonly ["get", "put", "post", "head", "trace", "patch", "delete", "options"];
+export declare const SWAGGER_SCHEMA_FILENAME = "swagger.schema.json";
+export type HttpMethod = (typeof ALL_OPERATION_METHODS)[number];
+export interface RequestContext {
+    headers?: Record<string, string>;
+    body?: unknown;
+    params?: unknown;
+    query?: unknown;
+}
+export interface ResponseContext {
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+export interface ApiOperation {
+    path: string;
+    method: string;
+    operationId: string;
+    request: RequestContext;
+    responses: Record<string, ResponseContext>;
+}
+export interface OperationSchemas {
+    request: SchemaObject;
+    responses: Record<string, SchemaObject>;
+}
+export interface ApiSchemas {
+    apis: Record<string, Record<string, OperationSchemas>>;
+    definitions?: Record<string, SchemaObject>;
+}
+export declare function buildApiSchemaFromYaml(yamlContent: string, organization: string, serviceName: string): ApiSchemas | null;
+export declare function generateSchemas(): Promise<void>;

package/dist-types/openapi/service-schema-generator.d.ts

@@ -0,0 +1,5 @@
+import { type ApiSchemas } from './generate-schema.ts';
+export declare function generateSchemasForService(serviceName: string, outputDir?: string): {
+    schema: ApiSchemas;
+    endpoint: string;
+}[];

package/dist-types/peggy/athena-peggy.d.ts

@@ -0,0 +1,13 @@
+declare function peg$SyntaxError(message: any, expected: any, found: any, location: any): Error;
+declare namespace peg$SyntaxError {
+    var buildMessage: (expected: any, found: any) => string;
+}
+declare namespace peg$SyntaxError {
+    var buildMessage: (expected: any, found: any) => string;
+}
+declare namespace peg$SyntaxError {
+    var buildMessage: (expected: any, found: any) => string;
+}
+declare function peg$parse(input: any, options: any): any;
+declare const peg$allowedStartRules: string[];
+export { peg$allowedStartRules as StartRules, peg$SyntaxError as SyntaxError, peg$parse as parse };