sasat 0.22.7 → 0.22.9

package/dist/index-lrk3IfPF.d.cts

@@ -0,0 +1,495 @@
+import { a as QueryResponse, c as SQLTransaction, i as DBClient, l as SqlValueType, n as ComparisonOperators, r as CommandResponse, s as SQLExecutor, t as ComparisonExpression$1 } from "./comparison-Bkk-qNRi.cjs";
+import * as _$mysql2_promise0 from "mysql2/promise";
+import { ConnectionOptions, PoolOptions } from "mysql2/promise";
+import { GraphQLResolveInfo } from "graphql";
+import Hashids from "hashids";
+import { GraphQLResolveInfo as GraphQLResolveInfo$1 } from "graphql/type/index.js";
+import pkg from "sqlstring";
+
+//#region src/db/connectors/mysql/client.d.ts
+declare class MysqlClient extends DBClient {
+  readonly connectionOption: ConnectionOptions;
+  release(): Promise<void>;
+  constructor(connectionOption: ConnectionOptions, logger?: (query: string) => void);
+  protected getConnection(): Promise<_$mysql2_promise0.Connection>;
+  transaction(): Promise<SQLTransaction>;
+  protected execSql(sql: string): Promise<QueryResponse | CommandResponse>;
+}
+//#endregion
+//#region src/db/formatQuery.d.ts
+declare const formatQuery: (str: TemplateStringsArray, ...params: any[]) => string;
+//#endregion
+//#region src/runtime/dsl/query/query.d.ts
+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;
+  join?: Join[];
+};
+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 | RawExpression;
+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;
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/queryToSql.d.ts
+declare const queryToSql: (query: Query) => string;
+//#endregion
+//#region src/runtime/types.d.ts
+type CustomCondition<Context> = (args: MakeConditionArg<Context>) => BooleanValueExpression;
+type AllowReadonly<T> = T | Readonly<T>;
+//#endregion
+//#region src/runtime/field.d.ts
+type Fields<Entity, Relation = Record<string, unknown>> = {
+  fields: AllowReadonly<keyof Entity & string>[];
+  relations?: Relation;
+  tableAlias?: string;
+  joinOn?: BooleanValueExpression;
+  joinType?: "INNER" | "LEFT";
+};
+//#endregion
+//#region src/runtime/dsl/query/createQueryResolveInfo.d.ts
+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;
+    };
+  };
+};
+//#endregion
+//#region src/runtime/sql/runQuery.d.ts
+type PagingOption$1 = {
+  numberOfItem: number;
+  where?: BooleanValueExpression;
+  offset?: number;
+  sort?: Sort[];
+  join?: Join[];
+};
+//#endregion
+//#region src/runtime/sasatDBDatasource.d.ts
+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;
+  join?: Join[];
+};
+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;
+  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 | null>;
+  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 | Readonly<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[];
+}
+//#endregion
+//#region src/db/getDbClient.d.ts
+declare const getDbClient: (option?: Partial<PoolOptions>, logger?: (query: string) => void) => DBClient;
+//#endregion
+//#region src/db/sql/expression/conditionExpression.d.ts
+type ConditionExpression<T> = ComparisonExpression$1<T> | CompositeCondition<T>;
+//#endregion
+//#region src/db/sql/expression/compositeCondition.d.ts
+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;
+}
+//#endregion
+//#region src/generatorv2/codegen/ts/scripts/typeDefinition.d.ts
+type TypeFieldDefinition = {
+  return: string;
+  args?: {
+    name: string;
+    type: string;
+  }[];
+};
+//#endregion
+//#region src/runtime/createTypeDef.d.ts
+type TypeDef = Record<string, TypeFieldDefinition>;
+declare const createTypeDef: (typeDefs: Record<string, TypeDef>, inputs: Record<string, TypeDef>) => string;
+//#endregion
+//#region src/runtime/date.d.ts
+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];
+//#endregion
+//#region src/runtime/dsl/factory.d.ts
+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;
+  };
+};
+//#endregion
+//#region src/runtime/dsl/query/sql/nodeToSql.d.ts
+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;
+};
+//#endregion
+//#region src/runtime/gqlResolveInfoToField.d.ts
+declare const gqlResolveInfoToField: <T extends Fields<any> = Fields<unknown>>(info: GraphQLResolveInfo) => T;
+//#endregion
+//#region src/runtime/id.d.ts
+type NumberIdEncoder = {
+  encode: (id: number) => string;
+  decode: (id: string) => number;
+};
+declare const makeNumberIdEncoder: (hashId: Hashids) => NumberIdEncoder;
+//#endregion
+//#region src/runtime/resolverMiddleware.d.ts
+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>;
+//#endregion
+//#region src/runtime/makeResolver.d.ts
+type ResolverArgs<Context, Params = unknown> = [_: unknown, params: Params, context: Context, info: GraphQLResolveInfo$1];
+type Resolver<Context, Params> = (_: unknown, params: Params, context: Context, info: GraphQLResolveInfo$1) => unknown;
+declare const makeResolver: <Context, RequiredParams, IncomingParams = RequiredParams>(resolver: Resolver<Context, RequiredParams>, middlewares?: ResolverMiddleware<Context, RequiredParams, IncomingParams>[]) => Resolver<Context, RequiredParams>;
+//#endregion
+//#region src/runtime/sql/sqlString.d.ts
+declare const escape: typeof pkg.escape;
+declare const SqlString: {
+  escape: (value: Parameters<typeof escape>[0]) => string;
+  escapeId: (name: string) => string;
+};
+//#endregion
+//#region src/runtime/util.d.ts
+declare const pick: <T extends object>(target: T, keys: Array<keyof T>) => {
+  [k: string]: T[keyof T];
+};
+//#endregion
+//#region src/util/assignDeep.d.ts
+type Obj = {
+  [key: string]: any;
+};
+declare const assignDeep: (base: Obj, ...objects: Obj[]) => Obj;
+//#endregion
+//#region src/util/dateUtil.d.ts
+declare const getCurrentDateTimeString: () => string;
+//#endregion
+//#region src/runtime/pagingOption.d.ts
+type DsPagingOption = {
+  numberOfItem: number;
+  where?: BooleanValueExpression;
+  offset?: number;
+  sort?: Sort[];
+};
+declare const pagingOption$1: (option: ListQueryOption) => DsPagingOption;
+//#endregion
+//#region src/index.d.ts
+type PagingOption = ListQueryOption;
+//#endregion
+export { RelationMap as A, CompositeCondition as C, ListQueryOption as D, EntityType as E, BooleanValueExpression as F, LockMode as I, Query as L, Fields as M, CustomCondition as N, QueryOptions as O, queryToSql as P, formatQuery as R, TypeFieldDefinition as S, EntityResult as T, getDayRange as _, pick as a, getTodayDateTimeString as b, ResolverMiddleware as c, gqlResolveInfoToField as d, Sql as f, dateToDatetimeString as g, dateToDateString as h, assignDeep as i, TableInfo as j, SasatDBDatasource as k, makeParamsMiddleware as l, dateOffset as m, pagingOption$1 as n, SqlString as o, QExpr as p, getCurrentDateTimeString as r, makeResolver as s, PagingOption as t, makeNumberIdEncoder as u, getDayRangeQExpr as v, getDbClient as w, createTypeDef as x, getTodayDateString as y, MysqlClient as z };