sasat 0.21.21 → 0.22.0

package/dist/index.d.ts

@@ -1,1167 +0,0 @@
-import pkg from 'sqlstring';
-import { GraphQLResolveInfo } from 'graphql/type';
-import Hashids from 'hashids';
-import { NestedPartial as NestedPartial$1 } from 'util/type';
-import { GraphQLResolveInfo as GraphQLResolveInfo$1 } from 'graphql';
-import * as mysql2 from 'mysql2';
-
-type ComparisonOperators = '=' | '>' | '<' | '>=' | '<=' | '<>';
-type AndOr = 'AND' | 'OR';
-type ComparisonExpression$1<T> = Partial<{
-    [P in keyof T]: T[P] | [ComparisonOperators | 'LIKE' | 'NOT LIKE', T[P]] | ['BETWEEN', T[P], T[P]] | ['IN', ...T[P][]] | ['IS NULL'] | ['IS NOT NULL'];
-}> & {
-    __type?: AndOr;
-};
-
-declare enum QueryNodeKind {
-    Field = 0,
-    Function = 1,
-    Table = 2,
-    Join = 3,
-    CompoundExpr = 4,
-    ComparisonExpr = 5,
-    IsNullExpr = 6,
-    Parenthesis = 7,
-    InExpr = 8,
-    BetweenExpr = 9,
-    ContainsExpr = 10,
-    Literal = 11,
-    Sort = 12,
-    Identifier = 13,
-    Exists = 14,
-    Raw = 15,
-    GroupBy = 16,
-    Over = 17,
-    Window = 18
-}
-type LockMode = 'FOR UPDATE' | 'FOR SHARE';
-type Query = {
-    select: SelectExpr[];
-    from: QueryTable;
-    where?: BooleanValueExpression;
-    groupBy?: GroupByExpr;
-    having?: BooleanValueExpression;
-    sort?: Sort[];
-    limit?: number;
-    offset?: number;
-    lock?: LockMode;
-};
-type GroupByExpr = {
-    kind: QueryNodeKind.GroupBy;
-    cols: (Field | Identifier)[];
-};
-type Field = {
-    kind: QueryNodeKind.Field;
-    table: string;
-    name: string;
-    alias?: string;
-};
-type Fn = {
-    kind: QueryNodeKind.Function;
-    fnName: string;
-    args: Value[];
-    over?: Over;
-    alias?: string;
-};
-type Over = {
-    kind: QueryNodeKind.Over;
-    orderBy?: Sort[];
-    partitionBy?: Identifier[];
-    window?: Window;
-};
-type Window = {
-    kind: QueryNodeKind.Window;
-    type: 'ROWS' | 'RANGE';
-    between: true;
-    start: WindowContent;
-    end: WindowContent;
-} | {
-    kind: QueryNodeKind.Window;
-    type: 'ROWS' | 'RANGE';
-    between: false;
-    value: WindowContent;
-};
-type WINDOW_TYPES_NO_ARG = 'UNBOUNDED PRECEDING' | 'UNBOUNDED FOLLOWING' | 'CURRENT ROW';
-type WINDOW_TYPES_ARG = 'PRECEDING' | 'FOLLOWING';
-type WindowContent = {
-    type: WINDOW_TYPES_NO_ARG;
-} | {
-    type: WINDOW_TYPES_ARG;
-    value: number;
-};
-type SelectExpr = Field | Fn | Identifier | RawExpression;
-type QueryTable = {
-    kind: QueryNodeKind.Table;
-    alias: string;
-    joins: Join[];
-} & ({
-    subquery?: false;
-    name: string;
-} | {
-    subquery: true;
-    query: Query;
-});
-type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'OUTER';
-type Join = {
-    kind: QueryNodeKind.Join;
-    type?: JoinType;
-    table: QueryTable;
-    conditions: BooleanValueExpression;
-};
-type ParenthesisExpression = {
-    kind: QueryNodeKind.Parenthesis;
-    expression: BooleanValueExpression;
-};
-type RawExpression = {
-    kind: QueryNodeKind.Raw;
-    expr: string;
-};
-type ExistsExpression = {
-    kind: QueryNodeKind.Exists;
-    query: Query | RawExpression;
-};
-type BooleanValueExpression = CompoundExpression | ComparisonExpression | IsNullExpression | ParenthesisExpression | InExpression | BetweenExpression | ContainsExpression | ExistsExpression;
-type IsNullExpression = {
-    kind: QueryNodeKind.IsNullExpr;
-    expr: Value;
-    isNot: boolean;
-};
-type CompoundOperator = 'AND' | 'OR';
-type CompoundExpression = {
-    kind: QueryNodeKind.CompoundExpr;
-    left: BooleanValueExpression;
-    operator: CompoundOperator;
-    right: BooleanValueExpression;
-};
-type ComparisonExpression = {
-    kind: QueryNodeKind.ComparisonExpr;
-    left: Value;
-    operator: ComparisonOperators;
-    right: Value;
-};
-type ContainType = 'start' | 'end' | 'contains';
-type ContainsExpression = {
-    kind: QueryNodeKind.ContainsExpr;
-    type: ContainType;
-    left: Value;
-    isNot: boolean;
-    right: string;
-};
-type InExpression = {
-    kind: QueryNodeKind.InExpr;
-    left: Value;
-    operator: 'IN' | 'NOT IN';
-} & ({
-    query: Query | RawExpression;
-} | {
-    right: Value[];
-});
-type BetweenExpression = {
-    kind: QueryNodeKind.BetweenExpr;
-    left: Value;
-    begin: Value;
-    end: Value;
-};
-type Value = Literal | Field | Fn | Identifier;
-type Identifier = {
-    kind: QueryNodeKind.Identifier;
-    identifier: string;
-};
-type Literal = {
-    kind: QueryNodeKind.Literal;
-    value: string | boolean | number | null;
-};
-type SortDirection = 'ASC' | 'DESC';
-type Sort = {
-    kind: QueryNodeKind.Sort;
-    field: Field | Fn | Identifier;
-    direction?: SortDirection;
-};
-
-declare const queryToSql: (query: Query) => string;
-
-type NestedPartial<T> = {
-    [K in keyof T]?: T[K] extends Array<infer R> ? Array<NestedPartial<R>> : NestedPartial<T[K]>;
-};
-
-interface SasatConfigDb {
-    host: string;
-    port: number;
-    user: string;
-    password?: string;
-    database: string;
-    ssl?: {
-        ca?: string[];
-    };
-}
-interface SasatConfigMigration {
-    table: string;
-    dir: string;
-    out: string;
-    target?: string;
-    db?: SasatConfigDb;
-}
-interface SasatConfigGenerator {
-    addJsExtToImportStatement: boolean;
-    gql: {
-        subscription: boolean;
-    };
-}
-interface SasatConfig {
-    db: SasatConfigDb;
-    migration: SasatConfigMigration;
-    generator: SasatConfigGenerator;
-}
-declare function setConfig(update: NestedPartial<SasatConfig>): SasatConfig;
-
-declare const formatQuery: (str: TemplateStringsArray, ...params: any[]) => string;
-
-type QueryResponse = Array<{
-    [key: string]: SqlValueType;
-}>;
-interface CommandResponse {
-    insertId: number;
-    affectedRows: number;
-    changedRows: number;
-}
-type SqlValueType = string | number | boolean | null;
-interface SQLExecutor {
-    rawQuery(sql: string): Promise<QueryResponse>;
-    rawCommand(sql: string): Promise<CommandResponse>;
-}
-declare abstract class SQLClient implements SQLExecutor {
-    protected logger: (query: string) => void;
-    rawQuery(sql: string): Promise<QueryResponse>;
-    rawCommand(sql: string): Promise<CommandResponse>;
-    query(templateString: TemplateStringsArray, ...params: any[]): Promise<QueryResponse>;
-    command(templateString: TemplateStringsArray, ...params: any[]): Promise<CommandResponse>;
-    protected abstract execSql(sql: string): Promise<QueryResponse | CommandResponse>;
-}
-declare abstract class SQLTransaction extends SQLClient {
-    abstract commit(): Promise<void>;
-    abstract rollback(): Promise<void>;
-}
-declare abstract class DBClient extends SQLClient {
-    protected _released: boolean;
-    protected constructor(logger?: (query: string) => void);
-    isReleased(): boolean;
-    abstract transaction(): Promise<SQLTransaction>;
-    abstract release(): Promise<void>;
-}
-
-type Fields<Entity, Relation = Record<string, unknown>> = {
-    fields: Array<keyof Entity & string>;
-    relations?: Relation;
-    tableAlias?: string;
-    joinOn?: BooleanValueExpression;
-};
-
-type MakeConditionArg<Context = unknown, Entity = unknown> = {
-    childTableAlias: string;
-    context?: Context;
-} & ({
-    parentTableAlias: string;
-    parent?: undefined;
-} | {
-    parent: Partial<Entity>;
-    parentTableAlias?: undefined;
-});
-type MakeCondition<Context, Entity = any> = (arg: MakeConditionArg<Context, Entity>) => BooleanValueExpression;
-type RelationInfo<Context = unknown> = {
-    table: string;
-    condition: MakeCondition<Context>;
-    array: boolean;
-    nullable: boolean;
-    requiredColumns: string[];
-};
-type RelationMap<Context = unknown> = {
-    [from: string]: {
-        [to: string]: RelationInfo<Context>;
-    };
-};
-type TableInfo = {
-    [tableName: string]: {
-        identifiableKeys: string[];
-        identifiableFields: string[];
-        columnMap: {
-            [fieldName: string]: string;
-        };
-    };
-};
-
-type PagingOption$1 = {
-    numberOfItem: number;
-    where?: BooleanValueExpression;
-    offset?: number;
-    sort?: Sort[];
-    join?: Join[];
-};
-
-type EntityType = Record<string, SqlValueType>;
-type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
-interface Repository<Entity, Identifiable, Creatable, Updatable> {
-    create(entity: Creatable): Promise<Entity>;
-    update(entity: Updatable): Promise<CommandResponse>;
-    delete(entity: Identifiable): Promise<CommandResponse>;
-}
-type ListQueryOption = {
-    numberOfItem: number;
-    offset?: number;
-    order?: string;
-    asc?: boolean;
-    join?: Join[];
-};
-type QueryOptions = {
-    where?: BooleanValueExpression;
-    sort?: Sort[];
-    limit?: number;
-    offset?: number;
-    lock?: LockMode;
-};
-declare abstract class SasatDBDatasource<Entity extends EntityType, Identifiable extends object, Creatable extends EntityType, Updatable extends Identifiable, EntityFields extends Fields<Entity>, QueryResult extends Partial<Entity> & Identifiable> implements Repository<Entity, Identifiable, Creatable, Updatable> {
-    protected client: SQLExecutor;
-    protected abstract relationMap: RelationMap<any>;
-    protected abstract tableInfo: TableInfo;
-    abstract readonly tableName: string;
-    abstract readonly fields: string[];
-    protected abstract readonly primaryKeys: string[];
-    protected abstract readonly identifyFields: string[];
-    protected abstract readonly autoIncrementColumn?: string | undefined;
-    protected queryLogger: (sql: string) => void;
-    protected commandLogger: (sql: string) => void;
-    constructor(client?: SQLExecutor);
-    protected abstract getDefaultValueString(): Partial<{
-        [P in keyof Entity]: Entity[P] | string | null | never;
-    }> | never;
-    create(entity: Creatable, option?: {
-        ignore?: boolean;
-        upsert?: {
-            updateColumns: string[];
-        };
-    }): Promise<Entity>;
-    createBulk(entities: Creatable[], option?: {
-        ignore?: boolean;
-        upsert?: {
-            updateColumns: string[];
-        };
-    }): Promise<CommandResponse>;
-    upsert<T extends Creatable & Partial<Entity>>(entity: T, updateFields?: (keyof T)[]): Promise<Entity>;
-    update(entity: Updatable): Promise<CommandResponse>;
-    updateWhere(update: Omit<Updatable, keyof Identifiable>, condition: BooleanValueExpression): Promise<CommandResponse>;
-    delete(entity: Identifiable): Promise<CommandResponse>;
-    deleteWhere(condition: BooleanValueExpression): Promise<CommandResponse>;
-    first(fields?: EntityFields, option?: QueryOptions, context?: unknown): Promise<QueryResult | null>;
-    find(fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
-    findPageable(paging: PagingOption$1, fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
-    private executeQuery;
-    private createIdentifiableExpression;
-    getRelationMap(): {
-        [to: string]: RelationInfo<any>;
-    };
-    protected fieldToColumn(fields: string[]): string[];
-}
-
-declare const Sql: {
-    select: (expr: SelectExpr) => string;
-    literal: (literal: Literal) => string;
-    fieldInCondition: (identifier: Field) => string;
-    fieldInSelect: (identifier: Field) => string;
-    identifier: (ident: Identifier) => string;
-    fn: (fn: Fn) => string;
-    value: (v: Value) => string;
-    between: (expr: BetweenExpression) => string;
-    contains: (expr: ContainsExpression) => string;
-    in: (expr: InExpression) => string;
-    comparison: (expr: ComparisonExpression) => string;
-    compound: (expr: CompoundExpression) => string;
-    isNull: (expr: IsNullExpression) => string;
-    paren: (expr: ParenthesisExpression) => string;
-    table: (table: QueryTable) => string;
-    join: (join: Join) => string;
-    booleanValue: (expr: BooleanValueExpression) => string;
-    exists: (expr: ExistsExpression) => string;
-    sort: (expr: Sort) => string;
-    sorts: (sorts: Sort[]) => string;
-    queryOrRaw: (expr: Query | RawExpression) => string;
-};
-
-declare const escape: typeof pkg.escape;
-declare const SqlString: {
-    escape: (value: Parameters<typeof escape>[0]) => string;
-    escapeId: (name: string) => string;
-};
-
-type ResolverArgs<Context, Params = unknown> = [
-    _: unknown,
-    params: Params,
-    context: Context,
-    info: GraphQLResolveInfo
-];
-type Resolver<Context, Params> = (_: unknown, params: Params, context: Context, info: GraphQLResolveInfo) => unknown;
-declare const makeResolver: <Context, RequiredParams, IncomingParams = RequiredParams>(resolver: Resolver<Context, RequiredParams>, middlewares?: ResolverMiddleware<Context, RequiredParams, IncomingParams>[]) => Resolver<Context, RequiredParams>;
-
-type ResolverMiddleware<Context, RequiredParams = any, IncomingParams = RequiredParams> = (args: ResolverArgs<Context, IncomingParams | RequiredParams>) => ResolverArgs<Context, RequiredParams | IncomingParams>;
-declare const makeParamsMiddleware: <RequiredParams, IncomingParams = RequiredParams>(update: (params: RequiredParams) => IncomingParams) => ResolverMiddleware<never, RequiredParams, IncomingParams>;
-
-type NumberIdEncoder = {
-    encode: (id: number) => string;
-    decode: (id: string) => number;
-};
-declare const makeNumberIdEncoder: (hashId: Hashids) => NumberIdEncoder;
-
-type CustomCondition<Context> = (args: MakeConditionArg<Context>) => BooleanValueExpression;
-
-type ContextConditionValue = {
-    kind: 'context';
-    field: string;
-    onNotDefined: OnNotDefinedAction;
-};
-type FixedConditionValue = {
-    kind: 'fixed';
-    value: string | number;
-};
-type TodayStartConditionValue = {
-    kind: 'today';
-    type: 'date' | 'datetime';
-    thresholdHour?: number;
-};
-type NowConditionValue = {
-    kind: 'now';
-};
-type OnNotDefinedAction = {
-    action: 'error';
-    message: string;
-} | {
-    action: 'defaultValue';
-    value: string | number;
-};
-type ConditionValue = ContextConditionValue | FixedConditionValue | TodayStartConditionValue | NowConditionValue;
-
-type QueryConditionValue = ConditionValue | FieldQueryConditionValue | ArgQueryConditionValue;
-type FieldQueryConditionValue = {
-    kind: 'field';
-    column: string;
-};
-type ArgQueryConditionValue = {
-    kind: 'arg';
-    name: string;
-    type: 'Int' | 'Float' | 'String' | string;
-};
-type QueryConditionNode = {
-    kind: 'comparison';
-    left: QueryConditionValue;
-    operator: ComparisonOperators;
-    right: QueryConditionValue;
-} | {
-    kind: 'between';
-    left: QueryConditionValue;
-    operator: 'BETWEEN';
-    begin: QueryConditionValue;
-    end: QueryConditionValue;
-};
-
-declare enum DBColumnTypes {
-    char = "char",
-    varchar = "varchar",
-    text = "text",
-    tinyInt = "tinyint",
-    smallInt = "smallint",
-    mediumInt = "mediumint",
-    int = "int",
-    bigInt = "bigint",
-    float = "float",
-    double = "double",
-    decimal = "decimal",
-    year = "year",
-    date = "date",
-    time = "time",
-    dateTime = "datetime",
-    timestamp = "timestamp",
-    boolean = "boolean"
-}
-type DBType = 'char' | 'varchar' | 'text' | 'tinyint' | 'smallint' | 'mediumint' | 'int' | 'bigint' | 'float' | 'double' | 'decimal' | 'year' | 'date' | 'time' | 'datetime' | 'timestamp' | 'boolean';
-type DBStringTypes = DBColumnTypes.char | DBColumnTypes.varchar;
-type DBTextTypes = DBColumnTypes.text;
-type DBIntegerTypes = DBColumnTypes.tinyInt | DBColumnTypes.smallInt | DBColumnTypes.mediumInt | DBColumnTypes.int | DBColumnTypes.bigInt;
-type DBFloatingTypes = DBColumnTypes.float | DBColumnTypes.double;
-type DBNumberTypes = DBIntegerTypes | DBFloatingTypes | DBColumnTypes.decimal;
-type DBDateTypes = DBColumnTypes.time | DBColumnTypes.date | DBColumnTypes.year;
-
-interface Serializable<T> {
-    serialize(): T;
-}
-
-type ForeignKeyReferentialAction = 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION';
-
-type Relation = 'One' | 'OneOrZero' | 'Many';
-
-type ColumnOptions = {
-    updatable: boolean;
-    autoIncrementHashId: boolean;
-    hashSalt?: string;
-};
-interface SerializedColumnBase {
-    hasReference: boolean;
-    fieldName: string;
-    columnName: string;
-    type: DBColumnTypes;
-    notNull: boolean;
-    default: SqlValueType | undefined;
-    zerofill: boolean;
-    signed: boolean | undefined;
-    autoIncrement: boolean;
-    length: number | undefined;
-    scale: number | undefined;
-    defaultCurrentTimeStamp: boolean;
-    onUpdateCurrentTimeStamp: boolean;
-    option: ColumnOptions;
-}
-interface SerializedNormalColumn extends SerializedColumnBase {
-    hasReference: false;
-}
-interface Reference {
-    parentTable: string;
-    parentColumn: string;
-    columnName: string;
-    relation: Relation;
-    parentFieldName?: string;
-    fieldName?: string;
-    relationName?: string;
-    onUpdate?: ForeignKeyReferentialAction;
-    onDelete?: ForeignKeyReferentialAction;
-    noFKey?: boolean;
-}
-interface SerializedReferenceColumn extends SerializedColumnBase {
-    hasReference: true;
-    reference: Reference;
-}
-type SerializedColumn = SerializedNormalColumn | SerializedReferenceColumn;
-
-interface Index {
-    constraintName: string;
-    columns: string[];
-}
-declare class DBIndex implements Index, Serializable<Index> {
-    readonly tableName: string;
-    readonly columns: string[];
-    readonly constraintName: string;
-    constructor(tableName: string, columns: string[]);
-    private toConstraintName;
-    addSql(): string;
-    dropSql(): string;
-    serialize(): Index;
-}
-
-type JoinConditionValue = {
-    kind: 'parent' | 'child';
-    field: string;
-} | ConditionValue;
-type JoinConditionRangeValue = {
-    kind: 'range';
-    begin: JoinConditionValue;
-    end: JoinConditionValue;
-} | DateRangeConditionValue;
-type DateRangeConditionValue = {
-    kind: 'date-range';
-    range: 'today';
-    thresholdHour?: number;
-};
-type JoinConditionNode = {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: ComparisonOperators;
-    right: JoinConditionValue;
-} | {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: 'BETWEEN';
-    right: JoinConditionRangeValue;
-} | {
-    kind: 'comparison';
-    left: JoinConditionValue;
-    operator: 'IN';
-    right: JoinConditionValue[];
-} | {
-    kind: 'isNull';
-    value: JoinConditionValue;
-    not: boolean;
-} | JoinCustomConditionNode;
-type JoinCustomConditionNode = {
-    kind: 'custom';
-    conditionName: string;
-    parentRequiredFields?: string[];
-    childRequiredFields?: string[];
-};
-
-type VirtualRelation = {
-    parentTable: string;
-    childTable: string;
-    parentFieldName?: string;
-    childFieldName?: string;
-    conditions: JoinConditionNode[];
-    parentType?: 'array' | 'nullable' | 'notnull';
-    childType?: 'array' | 'nullable' | 'notnull';
-};
-
-interface SerializedTable {
-    columns: SerializedColumn[];
-    primaryKey: string[];
-    uniqueKeys: string[][];
-    indexes: Index[];
-    tableName: string;
-    gqlOption: GQLOption;
-    virtualRelations: VirtualRelation[];
-}
-
-type GQLPrimitive = 'Int' | 'Float' | 'String' | 'Boolean' | 'ID';
-
-interface Column extends Serializable<SerializedColumn> {
-    fieldName(): string;
-    columnName(): string;
-    dataType(): DBColumnTypes;
-    toSql(): string;
-    isReference(): this is ReferenceColumn;
-    isNullable(): boolean;
-    tsType(): string;
-    gqlType(): GQLPrimitive;
-    isNullableOnCreate(): boolean;
-}
-declare class BaseColumn implements Column {
-    data: SerializedColumn;
-    table: Table;
-    constructor(data: SerializedColumn, table: Table);
-    fieldName(): string;
-    columnName(): string;
-    dataType(): DBColumnTypes;
-    tsType(): string;
-    gqlType(): GQLPrimitive;
-    isNullable(): boolean;
-    isNullableOnCreate(): boolean;
-    isReference(): this is ReferenceColumn;
-    serialize(): SerializedColumn;
-    toSql(): string;
-    isPrimary(): boolean;
-    isUpdatable(): boolean;
-}
-declare class ReferenceColumn extends BaseColumn {
-    data: SerializedReferenceColumn;
-    constructor(data: SerializedReferenceColumn, table: Table);
-    getConstraintName(): string;
-}
-
-declare class EntityName {
-    readonly name: string;
-    static fromTableName(tableName: string): EntityName;
-    constructor(name: string);
-    toString(): string;
-    creatableInterface(): string;
-    updatable(): string;
-    identifiableInterfaceName(): string;
-    relationTypeName(): string;
-    entityWithRelationTypeName(): string;
-    resultType(): string;
-    fieldsTypeName(): string;
-    dataSourceName(): string;
-    generatedDataSourceName(): string;
-    lowerCase(): string;
-    createInputName(): string;
-    updateInputName(): string;
-    identifyInputName(): string;
-    IDEncoderName(): string;
-}
-
-interface Table extends Serializable<SerializedTable> {
-    column(columnName: string): BaseColumn;
-    tableName: string;
-    gqlOption: GQLOption;
-    primaryKey: string[];
-}
-declare class TableHandler implements Table {
-    store: DataStore;
-    private indexes;
-    get index(): DBIndex[];
-    private _columns;
-    get columns(): BaseColumn[];
-    private readonly _virtualRelations;
-    get virtualRelations(): VirtualRelation[];
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): void;
-    primaryKey: string[];
-    readonly uniqueKeys: string[][];
-    readonly tableName: string;
-    private _gqlOption;
-    get gqlOption(): GQLOption;
-    constructor(table: Partial<SerializedTable> & Pick<SerializedTable, 'tableName'>, store: DataStore);
-    column(columnName: string): BaseColumn;
-    addColumn(column: BaseColumn, isPrimary?: boolean, isUnique?: boolean): void;
-    dropColumn(columnName: string): void;
-    serialize(): SerializedTable;
-    addReferences(ref: Reference, fieldName?: string, notNull?: boolean): this;
-    private getIndexConstraintName;
-    addIndex(...columns: string[]): this;
-    removeIndex(...columns: string[]): this;
-    addUniqueKey(...columnNames: string[]): this;
-    setPrimaryKey(...columnNames: string[]): this;
-    showCreateTable(): string;
-    hasColumn(columnName: string): boolean;
-    isColumnPrimary(columnName: string): boolean;
-    getEntityName(): EntityName;
-    setGQLOption(option: Partial<GQLOption>): void;
-    getReferenceColumns(): ReferenceColumn[];
-    addForeignKey(reference: Reference): void;
-    changeType(columnName: string, type: DBColumnTypes): void;
-    setDefault(columnName: string, value: string | number | null): void;
-    protected updateColumn(columnName: string, diff: Partial<SerializedColumn>): void;
-    getPrimaryKeyColumns(): BaseColumn[];
-}
-
-interface DataStore {
-    table(tableName: string): Table;
-}
-
-interface GqlFromContextParam {
-    column: string;
-    contextName?: string;
-}
-type GQLMutation = {
-    type: 'create' | 'update' | 'delete';
-    noReFetch: boolean;
-    middlewares: string[];
-    contextFields: GqlFromContextParam[];
-    subscription: {
-        enabled: boolean;
-        subscriptionFilter: string[];
-    };
-};
-type GQLQuery = {
-    type: 'single' | 'list-all' | 'list-paging';
-    name: string;
-    conditions: QueryConditionNode[];
-    middlewares: string[];
-} | {
-    type: 'primary';
-    name?: never;
-    conditions: never[];
-    middlewares: string[];
-};
-interface GQLOption {
-    enabled: boolean;
-    queries: GQLQuery[];
-    mutations: GQLMutation[];
-}
-
-declare const Queries: {
-    single: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    listAll: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    paging: (name: string, options?: {
-        conditions?: QueryConditionNode[];
-        middlewares?: string[];
-    }) => GQLQuery;
-    primary: (middlewares?: string[]) => GQLQuery;
-};
-
-type Option = {
-    noRefetch?: boolean;
-    middlewares?: string[];
-    contextFields?: GqlFromContextParam[];
-    subscription?: {
-        enabled: boolean;
-        subscriptionFilter?: string[];
-    } | boolean;
-};
-declare const Mutations: {
-    create: (options?: Option) => GQLMutation;
-    update: (options?: Option) => GQLMutation;
-    delete: (options?: Omit<Option, 'noRefetch'>) => GQLMutation;
-};
-
-declare const Conditions: {
-    readonly betweenRel: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
-    readonly betweenQuery: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
-    readonly custom: (conditionName: string, parentRequiredFields?: string[], childRequiredFields?: string[]) => JoinConditionNode;
-    readonly rel: {
-        readonly between: (left: JoinConditionValue, range: JoinConditionRangeValue) => JoinConditionNode;
-        readonly comparison: (left: JoinConditionValue, operator: ComparisonOperators, right: JoinConditionValue) => JoinConditionNode;
-        readonly in: (left: JoinConditionValue, right: JoinConditionValue[]) => JoinConditionNode;
-        readonly isNull: (value: JoinConditionValue) => JoinConditionNode;
-        readonly isNotNull: (value: JoinConditionValue) => JoinConditionNode;
-    };
-    readonly query: {
-        readonly between: (left: QueryConditionValue, begin: QueryConditionValue, end: QueryConditionValue) => QueryConditionNode;
-        readonly comparison: (left: QueryConditionValue, operator: ComparisonOperators, right: QueryConditionValue) => QueryConditionNode;
-    };
-    readonly value: {
-        readonly parent: (field: string) => JoinConditionValue;
-        readonly child: (field: string) => JoinConditionValue;
-        readonly contextOrError: (field: string, errorMessage: string) => ConditionValue;
-        readonly contextOrDefault: (field: string, defaultValue: string | number) => ConditionValue;
-        readonly fixed: (value: string | number) => ConditionValue;
-        readonly today: (thresholdHour?: number, date?: boolean) => ConditionValue;
-        readonly now: () => ConditionValue;
-        readonly field: (column: string) => QueryConditionValue;
-        readonly arg: (name: string, type: 'Int' | 'Float' | 'String') => QueryConditionValue;
-    };
-    readonly range: {
-        readonly values: (begin: JoinConditionValue, end: JoinConditionValue) => JoinConditionRangeValue;
-        readonly today: (thresholdHour?: number) => JoinConditionRangeValue;
-    };
-};
-
-declare abstract class ColumnBuilderBase {
-    readonly columnName: string;
-    protected _primary: boolean;
-    protected _notNull: boolean;
-    protected _unique: boolean;
-    protected _option: ColumnOptions;
-    protected _fieldName: string;
-    protected constructor(columnName: string);
-    fieldName(fieldName: string): this;
-    notNull(): this;
-    nullable(): this;
-    primary(): this;
-    unique(): this;
-    updatable(updatable: boolean): this;
-    abstract build(): {
-        data: SerializedColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
-}
-declare abstract class ColumnBuilder extends ColumnBuilderBase {
-    protected type: DBColumnTypes;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    protected _zerofill: boolean;
-    protected _signed: boolean | undefined;
-    protected _autoIncrement: boolean;
-    protected _default: SqlValueType | undefined;
-    protected _defaultCurrentTimeStamp: boolean;
-    protected _onUpdateCurrentTimeStamp: boolean;
-    protected constructor(name: string, type: DBColumnTypes, length?: number | undefined, scale?: number | undefined);
-    default(value: SqlValueType | undefined): this;
-    build(): {
-        data: SerializedNormalColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
-}
-declare class StringColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBStringTypes;
-    protected length?: number | undefined;
-    constructor(name: string, type: DBStringTypes, length?: number | undefined);
-    default(value: string | null | undefined): this;
-}
-declare class TextColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBTextTypes;
-    constructor(name: string, type: DBTextTypes);
-    default(value: string | null | undefined): this;
-}
-declare class NumberColumnBuilder extends ColumnBuilder {
-    constructor(name: string, type: DBNumberTypes, length?: number, scale?: number);
-    signed(): this;
-    unsigned(): this;
-    zerofill(): this;
-    default(value: number | null | undefined): this;
-}
-declare class IntegerColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBIntegerTypes;
-    protected length?: number | undefined;
-    constructor(name: string, type: DBIntegerTypes, length?: number | undefined);
-    autoIncrement(): this;
-}
-declare class FloatColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBFloatingTypes;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    constructor(name: string, type: DBFloatingTypes, length?: number | undefined, scale?: number | undefined);
-    autoIncrement(): this;
-}
-declare class DecimalColumnBuilder extends NumberColumnBuilder {
-    readonly name: string;
-    protected type: DBColumnTypes.decimal;
-    protected length?: number | undefined;
-    protected scale?: number | undefined;
-    constructor(name: string, type: DBColumnTypes.decimal, length?: number | undefined, scale?: number | undefined);
-}
-declare class DateColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBDateTypes;
-    constructor(name: string, type: DBDateTypes);
-    default(value: string | number | null | undefined): this;
-}
-declare class TimeStampColumnBuilder extends ColumnBuilder {
-    readonly name: string;
-    protected type: DBColumnTypes.timestamp | DBColumnTypes.dateTime;
-    constructor(name: string, type: DBColumnTypes.timestamp | DBColumnTypes.dateTime);
-    default(value: 'CURRENT_TIMESTAMP' | string | null | undefined): this;
-    defaultCurrentTimeStamp(): this;
-    onUpdateCurrentTimeStamp(): this;
-}
-declare class ReferenceColumnBuilder extends ColumnBuilderBase {
-    protected readonly ref: Reference;
-    protected readonly parent: Column;
-    constructor(ref: Reference, parent: Column);
-    notNull(): this;
-    nullable(): this;
-    primary(): this;
-    unique(): this;
-    build(): {
-        data: SerializedReferenceColumn;
-        isPrimary: boolean;
-        isUnique: boolean;
-    };
-}
-
-type CreateColumn = {
-    char: (length: number) => StringColumnBuilder;
-    varchar: (length: number) => StringColumnBuilder;
-    text: () => TextColumnBuilder;
-    tinyInt: (length?: number) => IntegerColumnBuilder;
-    smallInt: (length?: number) => IntegerColumnBuilder;
-    mediumInt: (length?: number) => IntegerColumnBuilder;
-    int: (length?: number) => IntegerColumnBuilder;
-    bigInt: (length?: number) => IntegerColumnBuilder;
-    float: (length?: number, scale?: number) => FloatColumnBuilder;
-    double: (length?: number, scale?: number) => FloatColumnBuilder;
-    decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
-    year: () => DateColumnBuilder;
-    date: () => DateColumnBuilder;
-    time: () => DateColumnBuilder;
-    dateTime: () => TimeStampColumnBuilder;
-    timestamp: () => TimeStampColumnBuilder;
-};
-
-interface MigrationTable extends Table {
-    addIndex(...columns: string[]): MigrationTable;
-    removeIndex(...columns: string[]): MigrationTable;
-    addColumn(name: string, create: (column: CreateColumn) => ColumnBuilder): MigrationTable;
-    _addColumn(column: SerializedColumn): MigrationTable;
-    dropColumn(columnName: string): MigrationTable;
-    addForeignKey(reference: Reference): MigrationTable;
-    changeColumnType(columnName: string, type: DBType): MigrationTable;
-    setDefault(columnName: string, value: string | number | null): MigrationTable;
-    enableGQL(): MigrationTable;
-    setGQLOption(option: GQLOption): MigrationTable;
-    addGQLQuery(...queries: GQLQuery[]): MigrationTable;
-    addGQLMutation(...mutations: GQLMutation[]): MigrationTable;
-}
-
-declare class ColumnCreator {
-    private table;
-    private name;
-    constructor(table: TableCreator, name: string);
-    char: (length: number) => StringColumnBuilder;
-    varchar: (length: number) => StringColumnBuilder;
-    text: () => TextColumnBuilder;
-    tinyInt: (length?: number) => IntegerColumnBuilder;
-    smallInt: (length?: number) => IntegerColumnBuilder;
-    mediumInt: (length?: number) => IntegerColumnBuilder;
-    int: (length?: number) => IntegerColumnBuilder;
-    bigInt: (length?: number) => IntegerColumnBuilder;
-    float: (length?: number, scale?: number) => FloatColumnBuilder;
-    double: (length?: number, scale?: number) => FloatColumnBuilder;
-    decimal: (length?: number, scale?: number) => DecimalColumnBuilder;
-    year: () => DateColumnBuilder;
-    date: () => DateColumnBuilder;
-    time: () => DateColumnBuilder;
-    dateTime: () => TimeStampColumnBuilder;
-    timestamp: () => TimeStampColumnBuilder;
-    private create;
-}
-
-interface TableBuilder {
-    autoIncrementHashId(columnName: string, option?: {
-        salt?: string;
-        bigint?: boolean;
-    }): TableBuilder;
-    column(columnName: string): ColumnCreator;
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): TableBuilder;
-    references(reference: Reference, notNull?: boolean): ColumnBuilderBase;
-    setPrimaryKey(...columnNames: string[]): TableBuilder;
-    addUniqueKey(...columnNames: string[]): TableBuilder;
-    createdAt(): TableBuilder;
-    updatedAt(): TableBuilder;
-    addIndex(...columns: string[]): TableBuilder;
-    enableGQL(): TableBuilder;
-    setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    addGQLQuery(...query: GQLQuery[]): TableBuilder;
-    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
-}
-declare class TableCreator implements TableBuilder {
-    tableName: string;
-    protected readonly store: DataStore;
-    private readonly table;
-    private readonly columns;
-    constructor(tableName: string, store: DataStore);
-    autoIncrementHashId(columnName: string, option?: {
-        salt?: string;
-        bigint?: boolean;
-    }): TableBuilder;
-    column(name: string): ColumnCreator;
-    addVirtualRelation(relation: Omit<VirtualRelation, 'childTable'>): this;
-    addColumn(column: ColumnBuilderBase): void;
-    addUniqueKey(...columnNames: string[]): TableBuilder;
-    references(ref: Reference): ReferenceColumnBuilder;
-    setPrimaryKey(...columnNames: string[]): TableBuilder;
-    create(): TableHandler;
-    createdAt(): TableBuilder;
-    updatedAt(): TableBuilder;
-    addIndex(...columns: string[]): TableBuilder;
-    enableGQL(): TableBuilder;
-    setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    addGQLQuery(...query: GQLQuery[]): TableBuilder;
-    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
-}
-
-interface MigrationStore extends DataStore {
-    createTable(tableName: string, tableCreator: (table: TableBuilder) => void): MigrationStore;
-    dropTable(tableName: string): MigrationStore;
-    table(tableName: string): MigrationTable;
-    sql(...sql: string[]): MigrationStore;
-    setConfig(config: NestedPartial$1<SasatConfig>): MigrationStore;
-}
-
-type TypeFieldDefinition = {
-    return: string;
-    args?: {
-        name: string;
-        type: string;
-    }[];
-};
-
-interface SasatMigration {
-    up: (store: MigrationStore) => void | Promise<void>;
-    down: (store: MigrationStore) => void | Promise<void>;
-    beforeUp?: () => void | Promise<void>;
-    afterUp?: () => void | Promise<void>;
-    beforeDown?: () => void | Promise<void>;
-    afterDown?: () => void | Promise<void>;
-}
-
-type StrOrNum = string | number;
-type ValueType = string | boolean | number | null;
-declare const QExpr: {
-    readonly field: (table: string, name: string, alias?: string) => Field;
-    readonly fn: (fnName: string, args: Value[], alias?: string) => Fn;
-    readonly window: (type: 'ROWS' | 'RANGE', value: WindowContent) => Window;
-    readonly windowBetween: (type: 'ROWS' | 'RANGE', start: WindowContent, end: WindowContent) => Window;
-    readonly paren: (expression: BooleanValueExpression) => ParenthesisExpression;
-    readonly table: (name: string, joins: Join[], alias: string) => QueryTable;
-    readonly subQueryTable: (query: Query, joins: Join[], alias: string) => QueryTable;
-    readonly join: (table: QueryTable, conditions: BooleanValueExpression, type?: JoinType) => Join;
-    readonly value: (value: ValueType) => Literal;
-    readonly sort: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
-    readonly order: (field: Field | Fn | Identifier, direction?: SortDirection) => Sort;
-    readonly ident: (identifier: string) => Identifier;
-    readonly id: (identifier: string) => Identifier;
-    readonly raw: (sql: string) => RawExpression;
-    readonly simpleWhere: (tableNameOrAlias: string, where: {
-        [field: string]: ValueType | [ComparisonOperators, ValueType];
-    }, isOr?: boolean) => BooleanValueExpression;
-    readonly and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-    readonly or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-    readonly eq: (left: Value, right: Value) => ComparisonExpression;
-    readonly neq: (left: Value, right: Value) => ComparisonExpression;
-    readonly gt: (left: Value, right: Value) => ComparisonExpression;
-    readonly gte: (left: Value, right: Value) => ComparisonExpression;
-    readonly lt: (left: Value, right: Value) => ComparisonExpression;
-    readonly lte: (left: Value, right: Value) => ComparisonExpression;
-    readonly comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
-    readonly contains: (left: Value, right: string) => BooleanValueExpression;
-    readonly notContains: (left: Value, right: string) => BooleanValueExpression;
-    readonly startsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly notStartsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly endsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly notEndsWith: (left: Value, right: string) => BooleanValueExpression;
-    readonly in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
-    readonly notIn: (left: Value, values: StrOrNum[]) => InExpression;
-    readonly between: (left: Value, begin: Value, end: Value) => BetweenExpression;
-    readonly isNull: (expr: Value) => IsNullExpression;
-    readonly isNotNull: (expr: Value) => IsNullExpression;
-    readonly exists: (query: RawExpression | Query) => ExistsExpression;
-    readonly conditions: {
-        simpleWhere: (tableNameOrAlias: string, where: {
-            [field: string]: ValueType | [ComparisonOperators, ValueType];
-        }, isOr?: boolean) => BooleanValueExpression;
-        and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-        or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
-        eq: (left: Value, right: Value) => ComparisonExpression;
-        neq: (left: Value, right: Value) => ComparisonExpression;
-        gt: (left: Value, right: Value) => ComparisonExpression;
-        gte: (left: Value, right: Value) => ComparisonExpression;
-        lt: (left: Value, right: Value) => ComparisonExpression;
-        lte: (left: Value, right: Value) => ComparisonExpression;
-        comparison: (left: Value, operator: ComparisonOperators, right: Value) => ComparisonExpression;
-        contains: (left: Value, right: string) => BooleanValueExpression;
-        notContains: (left: Value, right: string) => BooleanValueExpression;
-        startsWith: (left: Value, right: string) => BooleanValueExpression;
-        notStartsWith: (left: Value, right: string) => BooleanValueExpression;
-        endsWith: (left: Value, right: string) => BooleanValueExpression;
-        notEndsWith: (left: Value, right: string) => BooleanValueExpression;
-        in: (left: Value, right: StrOrNum[] | Query | RawExpression) => BooleanValueExpression;
-        notIn: (left: Value, values: StrOrNum[]) => InExpression;
-        between: (left: Value, begin: Value, end: Value) => BetweenExpression;
-        isNull: (expr: Value) => IsNullExpression;
-        isNotNull: (expr: Value) => IsNullExpression;
-        exists: (query: RawExpression | Query) => ExistsExpression;
-    };
-};
-
-declare const gqlResolveInfoToField: <T extends Fields<any> = Fields<unknown>>(info: GraphQLResolveInfo$1) => T;
-
-declare const getCurrentDateTimeString: () => string;
-
-declare const getDbClient: (connectionOption?: Partial<mysql2.ConnectionOptions> | undefined, poolOption?: Partial<mysql2.PoolOptions> | undefined, logger?: ((query: string) => void) | undefined) => DBClient;
-
-type Obj = {
-    [key: string]: any;
-};
-declare const assignDeep: (base: Obj, ...objects: Obj[]) => Obj;
-
-type TypeDef = Record<string, TypeFieldDefinition>;
-declare const createTypeDef: (typeDefs: Record<string, TypeDef>, inputs: Record<string, TypeDef>) => string;
-
-type ConditionExpression<T> = ComparisonExpression$1<T> | CompositeCondition<T>;
-
-declare class CompositeCondition<T> {
-    private type;
-    private conditions;
-    private constructor();
-    static or<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
-    static and<T>(conditions: ConditionExpression<T>[]): CompositeCondition<T>;
-    toSQL(): string;
-}
-
-declare const dateOffset: (date: Date, timeZoneHour?: number) => Date;
-declare const dateToDatetimeString: (d: Date) => string;
-declare const dateToDateString: (d: Date) => string;
-declare const getTodayDateString: (timeZoneHour?: number) => string;
-declare const getTodayDateTimeString: (timeZoneHour?: number) => string;
-declare const getDayRange: (date: Date, timeZoneHour?: number) => [string, string];
-declare const getDayRangeQExpr: (date: Date, timeZoneHour?: number) => [Literal, Literal];
-
-declare const pick: <T extends object>(target: T, keys: Array<keyof T>) => {
-    [k: string]: T[keyof T];
-};
-
-type DsPagingOption = {
-    numberOfItem: number;
-    where?: BooleanValueExpression;
-    offset?: number;
-    sort?: Sort[];
-};
-declare const pagingOption: (option: ListQueryOption) => DsPagingOption;
-
-type PagingOption = ListQueryOption;
-
-export { CompositeCondition, Conditions, Mutations, QExpr, Queries, SQLClient, SQLTransaction, SasatDBDatasource, Sql, SqlString, assignDeep, createTypeDef, dateOffset, dateToDateString, dateToDatetimeString, formatQuery, getCurrentDateTimeString, getDayRange, getDayRangeQExpr, getDbClient, getTodayDateString, getTodayDateTimeString, gqlResolveInfoToField, makeNumberIdEncoder, makeParamsMiddleware, makeResolver, pagingOption, pick, QExpr as qe, queryToSql, setConfig };
-export type { BooleanValueExpression, CommandResponse, ComparisonOperators, CustomCondition, EntityResult, EntityType, Fields, ListQueryOption, LockMode, MigrationStore, PagingOption, Query, QueryOptions, QueryResponse, Relation, RelationMap, ResolverMiddleware, SQLExecutor, SasatMigration, TableInfo, TypeFieldDefinition };