@tachybase/module-collection 1.6.24 → 1.6.26

package/dist/node_modules/node-sql-parser/types.d.ts

@@ -0,0 +1,555 @@
+// Type definitions for node-sql-parser 1.0
+// Project: https://github.com/taozhi8833998/node-sql-parser#readme
+// Definitions by: taozhi8833998 <https://github.com/taozhi8833998>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+export interface With {
+  name: { value: string };
+  stmt: {
+    _parentheses?: boolean;
+    tableList: string[];
+    columnList: string[];
+    ast: Select;
+  };
+  columns?: any[];
+}
+import { LocationRange } from "pegjs";
+
+export { LocationRange, Location } from "pegjs";
+
+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;
+  collate?: { collate: CollateExpr };
+}
+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: Array<
+    | {
+        cond: Binary;
+        result: ExpressionValue;
+        type: "when";
+      }
+    | {
+        result: ExpressionValue;
+        type: "else";
+      }
+  >;
+}
+export interface Cast {
+  type: "cast";
+  keyword: "cast";
+  expr: ExpressionValue;
+  symbol: "as";
+  target: {
+    dataType: string;
+    quoted?: string;
+  }[];
+}
+export interface AggrFunc {
+  type: "aggr_func";
+  name: string;
+  args: {
+    expr: ExpressionValue;
+    distinct: "DISTINCT" | null;
+    orderby: OrderBy[] | null;
+    parentheses?: boolean;
+  };
+  loc?: LocationRange;
+}
+
+export type 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 type Param = { type: "param"; value: string; loc?: LocationRange };
+
+export type Value = { type: string; value: any; loc?: LocationRange };
+
+export type 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 type ExprList = {
+  type: "expr_list";
+  value: ExpressionValue[];
+  loc?: LocationRange;
+  parentheses?: boolean;
+  separator?: string;
+};
+
+export type PartitionBy = {
+  type: 'expr';
+  expr: ColumnRef[];
+}[];
+
+export type WindowSpec = {
+  name: null;
+  partitionby: PartitionBy;
+  orderby: OrderBy[] | null;
+  window_frame_clause: string | null; };
+
+export type AsWindowSpec = string | { window_specification: WindowSpec; parentheses: boolean };
+
+export type NamedWindowExpr = {
+  name: string;
+  as_window_specification: AsWindowSpec;
+};
+
+export type 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;
+  returning?: Returning
+}
+export interface Returning {
+  type: 'returning';
+  columns: ColumnRef | Select;
+}
+export interface Update {
+  type: "update";
+  db: string | null;
+  table: Array<From | Dual> | null;
+  set: SetList[];
+  where: Binary | Function | null;
+  loc?: LocationRange;
+  returning?: Returning
+}
+export interface Delete {
+  type: "delete";
+  table: any;
+  from: Array<From | Dual>;
+  where: Binary | Function | null;
+  loc?: LocationRange;
+  returning?: Returning
+}
+
+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"];
+
+type KeywordComment = {
+  type: "comment";
+  keyword: "comment";
+  symbol?: "=";
+  value: string;
+};
+
+type CollateExpr = {
+  type: "collate";
+  symbol?: "=";
+  value: string;
+};
+
+type DataType = {
+  dataType: string;
+  length?: number;
+  parentheses?: true;
+  scale?: number;
+  suffix?: Timezone | (KW_UNSIGNED | KW_ZEROFILL)[];
+  array?: "one" | "two";
+};
+
+type LiteralNotNull = {
+  type: "not null";
+  value: "not null";
+};
+
+type LiteralNull = { type: "null"; value: null };
+
+type LiteralNumeric = number | { type: "bigint"; value: string };
+
+type ColumnConstraint = {
+  default_val: {
+    type: "default";
+    value: any;
+  };
+  nullable: LiteralNotNull | LiteralNull;
+};
+
+type 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;
+
+type IndexType = {
+  keyword: "using";
+  type: "btree" | "hash" | "gist" | "gin";
+};
+
+type IndexOption = {
+  type: "key_block_size";
+  symbol?: "=";
+  expr: LiteralNumeric;
+};
+
+type CreateIndexDefinition = {
+  index?: string;
+  definition: ColumnRef[];
+  keyword: "index" | "key";
+  index_type?: IndexType;
+  resource: "index";
+  index_options?: IndexOption[];
+};
+
+type CreateFulltextSpatialIndexDefinition = {
+  index?: string;
+  definition: ColumnRef[];
+  keyword?:
+    | "fulltext"
+    | "spatial"
+    | "fulltext key"
+    | "spatial key"
+    | "fulltext index"
+    | "spatial index";
+  index_options?: IndexOption[];
+  resource: "index";
+};
+
+type ConstraintName = { keyword: "constraint"; constraint: string };
+
+type CreateConstraintPrimary = {
+  constraint?: ConstraintName["constraint"];
+  definition: ColumnRef[];
+  constraint_type: "primary key";
+  keyword?: ConstraintName["keyword"];
+  index_type?: IndexType;
+  resource: "constraint";
+  index_options?: IndexOption[];
+};
+
+type 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[];
+};
+
+type CreateConstraintForeign = {
+  constraint?: ConstraintName["constraint"];
+  definition: ColumnRef[];
+  constraint_type: "FOREIGN KEY";
+  keyword?: ConstraintName["keyword"];
+  index?: string;
+  resource: "constraint";
+  reference_definition?: any;
+};
+
+type 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: "aggregate" | "table" | "trigger" | "extension" | "function" | "index" | "database" | "schema" | "view" | "domain" | "type" | "user";
+  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 class Parser {
+  constructor();
+
+  parse(sql: string, opt?: Option): TableColumnAst;
+
+  astify(sql: string, opt?: Option): AST[] | AST;
+
+  sqlify(ast: AST[] | AST, opt?: Option): string;
+
+  exprToSQL(ast: any, opt?: Option): string;
+
+  whiteListCheck(
+    sql: string,
+    whiteList: string[],
+    opt?: Option
+  ): Error | undefined;
+
+  tableList(sql: string, opt?: Option): string[];
+
+  columnList(sql: string, opt?: Option): string[];
+}

package/dist/node_modules/node-sql-parser/umd/athena.umd.d.ts

@@ -0,0 +1 @@
+export * from '../types';