sasat 0.14.8 → 0.14.11

package/lib/cli/commands/dumpDb.js

@@ -4,7 +4,7 @@ import { SqlString } from '../../runtime/sql/sqlString.js';
 import { writeYmlFile } from '../../util/fsUtil.js';
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
 import { config } from '../../config/config.js';
-import { getDbClient } from "../../db/getDbClient.js";
+import { getDbClient } from '../../db/getDbClient.js';
 export const dumpDB = async () => {
     const con = getDbClient();
     try {

package/lib/cli/commands/migrate.js

@@ -4,7 +4,7 @@ import { Parser } from '../../parser/parser.js';
 import { CodeGenerateController } from '../../generator/controller.js';
 import { DataStoreHandler } from '../../migration/dataStore.js';
 import { writeCurrentSchema } from '../../util/fsUtil.js';
-import { getDbClient } from "../../db/getDbClient.js";
+import { getDbClient } from '../../db/getDbClient.js';
 export const migrate = async (options) => {
     let current;
     try {

package/lib/db/connectors/mockClient.d.ts

@@ -1,4 +1,4 @@
-import { DBClient, SQLTransaction } from "./dbClient.js";
+import { DBClient, SQLTransaction } from './dbClient.js';
 declare class MockDBTransaction extends SQLTransaction {
     commit(): Promise<void>;
     protected execSql(): Promise<never[]>;

package/lib/db/connectors/mockClient.js

@@ -1,4 +1,4 @@
-import { DBClient, SQLTransaction } from "./dbClient.js";
+import { DBClient, SQLTransaction } from './dbClient.js';
 class MockDBTransaction extends SQLTransaction {
     commit() {
         return Promise.resolve();

package/lib/db/connectors/mysql/client.js

@@ -1,5 +1,5 @@
 import { DBClient } from '../dbClient.js';
-import * as mysql from 'mysql';
+import * as mysql from 'mysql2';
 import { MySqlTransaction } from './transaction.js';
 import { config } from '../../../config/config.js';
 import { promisify } from 'util';

package/lib/db/connectors/mysql/transaction.d.ts

@@ -1,4 +1,4 @@
-import * as mysql from 'mysql';
+import * as mysql from 'mysql2';
 import { CommandResponse, QueryResponse, SQLTransaction } from '../dbClient.js';
 export declare class MySqlTransaction extends SQLTransaction {
     private connection;

package/lib/db/formatQuery.js

@@ -1,4 +1,4 @@
-import { SqlString } from "../runtime/sql/sqlString.js";
+import { SqlString } from '../runtime/sql/sqlString.js';
 export const formatQuery = (str, ...params) => {
     let ret = str[0];
     for (let i = 0; i < params.length; i++) {

package/lib/db/sql/createTable/createTableParser.js

@@ -205,7 +205,7 @@ export class CreateTableParser {
             targetTable,
             targetColumn,
             columnName,
-            relation: isColumnUnique ? "OneOrZero" : "Many",
+            relation: isColumnUnique ? 'OneOrZero' : 'Many',
             relationName: sameTableRefs.length !== 0 ? targetTable + sameTableRefs.length : undefined,
             onUpdate,
             onDelete,

package/lib/db/sql/createTable/createTableSerializer.js

@@ -65,7 +65,7 @@ const startStrMap = [
                 targetTable,
                 targetColumn,
                 columnName,
-                relation: isColumnUnique ? "OneOrZero" : "Many",
+                relation: isColumnUnique ? 'OneOrZero' : 'Many',
                 relationName: sameTableRefs.length !== 0 ? targetTable + sameTableRefs.length : undefined,
                 onUpdate: onUpdate !== -1 ? tokens[onUpdate + 1].value : undefined,
                 onDelete: onDelete !== -1 ? tokens[onDelete + 1].value : undefined,

package/lib/generator/ts/code/factory.d.ts

@@ -4,7 +4,7 @@ import { Block } from './node/block.js';
 import { Class } from './node/class.js';
 import { EnumDeclaration } from './node/enumDeclaration.js';
 import { EnumMember } from './node/enumMember.js';
-import { ExpressionStatement } from './node/ExpressionStatement.js';
+import { ExpressionStatement } from './node/expressionStatement.js';
 import { ExtendsClause } from './node/extendsClause.js';
 import { IfStatement } from './node/ifStatement.js';
 import { ImplementsClause } from './node/implementsClause.js';
@@ -35,13 +35,13 @@ export declare const tsg: {
     implements: (...args: TypeReference[]) => ImplementsClause;
     interface: (name: string) => TsInterface;
     method: (methodName: string, params: Parameter[], returnType: import("./node/type/type.js").TsType, body: import("./abstruct/statement.js").TsStatement[]) => MethodDeclaration;
-    parameter: (paramName: string, type?: TypeReference | TypeLiteral | IntersectionType | ArrayType | UnionType | undefined) => Parameter;
+    parameter: (paramName: string, type?: import("./node/type/type.js").TsType | undefined) => Parameter;
     propertyAssign: (key: string, value?: Exp.Identifier | Exp.Literal | undefined) => PropertyAssignment;
     propertyDeclaration: (propertyName: string, type: import("./node/type/type.js").TsType, optional?: boolean | undefined) => PropertyDeclaration;
     propertySignature: (propertyName: string, type: import("./node/type/type.js").TsType, isOptional?: boolean | undefined, isReadOnly?: boolean | undefined) => PropertySignature;
     return: (expression: Exp.TsExpression) => ReturnStatement;
     spreadAssign: (identifier: Exp.Identifier | Exp.ObjectLiteral | Exp.ArrayLiteral) => SpreadAssignment;
-    variable: (flag: "const" | "let", variableName: string | Exp.Identifier, expression: Exp.TsExpression | Exp.Identifier, type?: TypeReference | TypeLiteral | IntersectionType | ArrayType | UnionType | undefined) => VariableDeclaration;
+    variable: (flag: "const" | "let", variableName: string | Exp.Identifier, expression: Exp.TsExpression | Exp.Identifier, type?: import("./node/type/type.js").TsType | undefined) => VariableDeclaration;
     methodModifiers: () => MethodModifiers;
     propertyModifiers: () => PropertyModifiers;
     arrayType: (type: import("./node/type/type.js").TsType) => ArrayType;
@@ -49,8 +49,8 @@ export declare const tsg: {
     unionType: (types: import("./node/type/type.js").TsType[]) => UnionType;
     typeAlias: (alias: string, type: import("./node/type/type.js").TsType) => TypeAliasDeclaration;
     typeLiteral: (properties?: PropertySignature[] | undefined) => TypeLiteral;
-    typeRef: (typeName: string, typeArguments?: (Exp.Identifier | TypeReference | TypeLiteral | IntersectionType | ArrayType | UnionType)[] | undefined) => TypeReference;
-    arrowFunc: (params: Parameter[], returnType: TypeReference | TypeLiteral | IntersectionType | ArrayType | UnionType | undefined, body: Exp.TsExpression | Block) => Exp.ArrowFunction;
+    typeRef: (typeName: string, typeArguments?: (Exp.Identifier | import("./node/type/type.js").TsType)[] | undefined) => TypeReference;
+    arrowFunc: (params: Parameter[], returnType: import("./node/type/type.js").TsType | undefined, body: Exp.TsExpression | Block) => Exp.ArrowFunction;
     async: (expression: Exp.ArrowFunction) => Exp.AsyncExpression;
     await: (expression: Exp.TsExpression) => Exp.AwaitExpression;
     binary: (left: Exp.TsExpression, operator: Exp.BinaryExpressionToken, right: Exp.TsExpression) => Exp.BinaryExpression;

package/lib/generator/ts/code/factory.js

@@ -4,7 +4,7 @@ import { Block } from './node/block.js';
 import { Class } from './node/class.js';
 import { EnumDeclaration } from './node/enumDeclaration.js';
 import { EnumMember } from './node/enumMember.js';
-import { ExpressionStatement } from './node/ExpressionStatement.js';
+import { ExpressionStatement } from './node/expressionStatement.js';
 import { ExtendsClause } from './node/extendsClause.js';
 import { IfStatement } from './node/ifStatement.js';
 import { ImplementsClause } from './node/implementsClause.js';

package/lib/generator/ts/code/importDeclaration.js

@@ -1,4 +1,4 @@
-import { config } from "../../../config/config.js";
+import { config } from '../../../config/config.js';
 export class ImportDeclaration {
     constructor(types, module) {
         this.types = types;

package/lib/generator/ts/code/node/expressions.d.ts

@@ -1,5 +1,5 @@
 import { TsCode } from '../abstruct/tsCode.js';
-import { ExpressionStatement } from './ExpressionStatement.js';
+import { ExpressionStatement } from './expressionStatement.js';
 import { SpreadAssignment } from './spreadAssignment.js';
 import { PropertyAssignment } from './propertyAssignment.js';
 import { Parameter } from './parameter.js';

package/lib/generator/ts/code/node/expressions.js

@@ -1,5 +1,5 @@
 import { TsCode } from '../abstruct/tsCode.js';
-import { ExpressionStatement } from './ExpressionStatement.js';
+import { ExpressionStatement } from './expressionStatement.js';
 import { Parameter } from './parameter.js';
 export class TsExpression extends TsCode {
     constructor() {

package/lib/generator/ts/code/node/parameter.d.ts

@@ -1,8 +1,9 @@
+import { TsType } from './type/type.js';
 import { TsCode } from '../abstruct/tsCode.js';
 export declare class Parameter extends TsCode {
     private paramName;
     private type?;
-    constructor(paramName: string, type?: import("./type/typeReference.js").TypeReference | import("./type/typeLiteral.js").TypeLiteral | import("./type/intersectionType.js").IntersectionType | import("./type/arrayType.js").ArrayType | import("./type/unionType.js").UnionType | undefined);
+    constructor(paramName: string, type?: TsType | undefined);
     protected toTsString(): string;
     static arrayToString(params: Parameter[]): string;
 }

package/lib/generator/ts/code/node/variableDeclaration.d.ts

@@ -1,12 +1,13 @@
 import { ExportableDeclaration } from '../abstruct/exportableDeclaration.js';
 import { Identifier, TsExpression } from './expressions.js';
+import { TsType } from './type/type.js';
 declare type VariableType = 'const' | 'let';
 export declare class VariableDeclaration extends ExportableDeclaration {
     private readonly flag;
     private readonly expression;
     private readonly type?;
     private readonly variableName;
-    constructor(flag: VariableType, variableName: Identifier | string, expression: TsExpression | Identifier, type?: import("./type/typeReference.js").TypeReference | import("./type/typeLiteral.js").TypeLiteral | import("./type/intersectionType.js").IntersectionType | import("./type/arrayType.js").ArrayType | import("./type/unionType.js").UnionType | undefined);
+    constructor(flag: VariableType, variableName: Identifier | string, expression: TsExpression | Identifier, type?: TsType | undefined);
     protected toTsString(): string;
 }
 export {};

package/lib/generator/ts/db/generatedRepositoryGenerator.js

@@ -84,12 +84,13 @@ export class GeneratedRepositoryGenerator {
                 .call(qExpr.property('field').call(tsg.identifier('tableName'), tsg.string(it.name)), qExpr.property('value').call(tsg.identifier(it.name))));
             const body = [
                 tsg.variable('const', 'tableName', tsg.identifier('fields?.tableAlias || this.tableName')),
-                tsg.return(tsg.identifier(it.returnType.isArray ? 'this.find' : 'this.first').call(tsg.identifier('fields'), exps.length === 1
+                tsg.return(tsg.identifier(it.returnType.isArray ? 'this.find' : 'this.first').call(tsg.identifier('fields'), tsg.object()
+                    .addProperties(tsg.propertyAssign('where', exps.length === 1
                     ? exps[0]
                     : qExpr
                         .property('conditions')
                         .property('and')
-                        .call(...exps))),
+                        .call(...exps))))),
             ];
             const returnType = tsg
                 .typeRef('EntityResult', [

package/lib/generator/ts/gql/mutationGenerator.js

@@ -3,10 +3,10 @@ import { VariableDeclaration } from '../code/node/variableDeclaration.js';
 import { PropertyAssignment } from '../code/node/propertyAssignment.js';
 import { TypeReference } from '../code/node/type/typeReference.js';
 import { Parameter } from '../code/node/parameter.js';
-import { Block } from '../code/node/Block.js';
+import { Block } from '../code/node/block.js';
 import { ReturnStatement } from '../code/node/returnStatement.js';
 import { SpreadAssignment } from '../code/node/spreadAssignment.js';
-import { ExpressionStatement } from '../code/node/ExpressionStatement.js';
+import { ExpressionStatement } from '../code/node/expressionStatement.js';
 import { IntersectionType } from '../code/node/type/intersectionType.js';
 import { KeywordTypeNode } from '../code/node/type/typeKeyword.js';
 import { IfStatement } from '../code/node/ifStatement.js';

package/lib/generator/ts/staticFiles.js

@@ -1,4 +1,4 @@
-import { ImportDeclaration } from "./code/importDeclaration.js";
+import { ImportDeclaration } from './code/importDeclaration.js';
 const contextFile = `\
 ${new ImportDeclaration(['BaseGqlContext'], './__generated__/context').toString()}
 export interface GqlContext extends BaseGqlContext {}

package/lib/migration/front/tableMigrator.d.ts

@@ -6,7 +6,7 @@ import { GqlOption } from '../data/gqlOption.js';
 import { Column } from '../serializable/column.js';
 import { SerializedTable } from '../serialized/serializedStore.js';
 import { DBType } from '../column/columnTypes.js';
-import { DBIndex } from "../data/index.js";
+import { DBIndex } from '../data/index.js';
 export interface MigrationTable extends Table {
     addIndex(...columns: string[]): MigrationTable;
     removeIndex(...columns: string[]): MigrationTable;

package/lib/migration/front/tableMigrator.js

@@ -2,7 +2,7 @@ import { TableHandler } from '../serializable/table.js';
 import { NormalColumn } from '../serializable/column.js';
 import { SqlCreator } from '../../db/sql/sqlCreater.js';
 import { SqlString } from '../../runtime/sql/sqlString.js';
-import { DBIndex } from "../data/index.js";
+import { DBIndex } from '../data/index.js';
 export class TableMigrator {
     constructor(table, store) {
         this.table = table;

package/lib/migration/migrationReader.js

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import ts from 'typescript';
 import { readInitialSchema } from '../util/fsUtil.js';
-import { config } from "../config/config.js";
+import { config } from '../config/config.js';
 export class MigrationReader {
     read(onMigrate) {
         const files = fs.readdirSync(MigrationTargetResolver.getMigrationDir());
@@ -21,11 +21,11 @@ export class MigrationReader {
         return store;
     }
     static getTsConfig() {
-        const configFileName = ts.findConfigFile("./", ts.sys.fileExists, "tsconfig.json");
+        const configFileName = ts.findConfigFile('./', ts.sys.fileExists, 'tsconfig.json');
         if (!configFileName)
             return undefined;
         const configFile = ts.readConfigFile(configFileName, ts.sys.readFile);
-        return ts.parseJsonConfigFileContent(configFile.config, ts.sys, "./").options;
+        return ts.parseJsonConfigFileContent(configFile.config, ts.sys, './').options;
     }
     static readMigration(store, fileName, direction) {
         const file = fs.readFileSync(path.join(MigrationTargetResolver.getMigrationDir(), fileName)).toString();

package/lib/migration/migrationTargetResolver.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { config } from '../config/config.js';
-import { getDbClient } from "../db/getDbClient.js";
+import { getDbClient } from '../db/getDbClient.js';
 export var Direction;
 (function (Direction) {
     Direction["Up"] = "up";

package/lib/migration/serialized/serializedColumn.d.ts

@@ -1,7 +1,7 @@
 import { DBColumnTypes } from '../column/columnTypes.js';
 import { SqlValueType } from '../../db/connectors/dbClient.js';
 import { ForeignKeyReferentialAction } from '../data/foreignKey.js';
-import { Relation } from "../data/relation.js";
+import { Relation } from '../data/relation.js';
 interface SerializedColumnBase {
     hasReference: boolean;
     fieldName: string;

package/lib/parser/node/relationNode.d.ts

@@ -2,7 +2,7 @@ import { TypeNode } from './typeNode.js';
 import { EntityNode } from './entityNode.js';
 import { ReferenceColumn } from '../../migration/serializable/column.js';
 import { EntityName } from './entityName.js';
-import { Relation } from "../../migration/data/relation.js";
+import { Relation } from '../../migration/data/relation.js';
 export declare class RelationNode {
     readonly parent: EntityNode;
     readonly relationName: string | undefined;

package/lib/parser/node/repositoryNode.js

@@ -36,7 +36,7 @@ export class RepositoryNode {
         const refMethods = (relation) => {
             return new FindMethodNode([
                 new ParameterNode(relation.fromField, new TypeNode(relation.parent.field(relation.fromField).dbType, false, false)),
-            ], new TypeNode(EntityName.fromTableName(relation.parent.repository.tableName), relation.relation === "Many", false), false);
+            ], new TypeNode(EntityName.fromTableName(relation.parent.repository.tableName), relation.relation === 'Many', false), false);
         };
         const referencedByMethod = (relation) => {
             const to = relation.parent.repository.root.findRepository(relation.toEntityName);

package/lib/runtime/dsl/factory.d.ts

@@ -1,6 +1,6 @@
-import { BooleanValueExpression, Literal, IsNullExpression, Value, ParenthesisExpression, Field, BetweenExpression, InExpression, ComparisonExpression, Fn, QueryTable, Join } from './query/query.js';
+import { BetweenExpression, BooleanValueExpression, ComparisonExpression, Field, Fn, InExpression, IsNullExpression, Join, JoinType, Literal, ParenthesisExpression, QueryTable, Sort, SortDirection, Value } from './query/query.js';
 export declare const QExpr: {
-    conditions: {
+    readonly conditions: {
         and: (...expr: BooleanValueExpression[]) => BooleanValueExpression;
         or: (...expr: BooleanValueExpression[]) => BooleanValueExpression;
         eq: (left: Value, right: Value) => ComparisonExpression;
@@ -21,10 +21,12 @@ export declare const QExpr: {
         isNull: (expr: Value) => IsNullExpression;
         isNotNull: (expr: Value) => IsNullExpression;
     };
-    field: (table: string, name: string, alias?: string | undefined) => Field;
-    fn: (fnName: string, args: Value[]) => Fn;
-    paren: (expression: BooleanValueExpression) => ParenthesisExpression;
-    table: (name: string, joins: Join[], alias?: string | undefined) => QueryTable;
-    join: (table: QueryTable, conditions: BooleanValueExpression, type?: "INNER" | "LEFT" | "RIGHT" | "OUTER" | undefined) => Join;
-    value: (value: string | boolean | number | null) => Literal;
+    readonly field: (table: string, name: string, alias?: string | undefined) => Field;
+    readonly fn: (fnName: string, args: Value[]) => Fn;
+    readonly paren: (expression: BooleanValueExpression) => ParenthesisExpression;
+    readonly table: (name: string, joins: Join[], alias?: string | undefined) => QueryTable;
+    readonly join: (table: QueryTable, conditions: BooleanValueExpression, type?: JoinType | undefined) => Join;
+    readonly value: (value: string | boolean | number | null) => Literal;
+    readonly sort: (field: Field, direction: SortDirection) => Sort;
+    readonly order: (field: Field, direction: SortDirection) => Sort;
 };

package/lib/runtime/dsl/factory.js

@@ -97,6 +97,11 @@ const literal = (value) => ({
     kind: QueryNodeKind.Literal,
     value,
 });
+const sort = (field, direction) => ({
+    kind: QueryNodeKind.Sort,
+    field,
+    direction,
+});
 export const QExpr = {
     conditions,
     field,
@@ -105,4 +110,6 @@ export const QExpr = {
     table,
     join,
     value: literal,
+    sort,
+    order: sort,
 };

package/lib/runtime/dsl/mutation/mutation.d.ts

@@ -1,6 +1,6 @@
 import { SqlValueType } from '../../../db/connectors/dbClient.js';
 import { TableInfo } from '../query/createQueryResolveInfo.js';
-import { BooleanValueExpression } from "../query/query.js";
+import { BooleanValueExpression } from '../query/query.js';
 declare type ValueSet = {
     field: string;
     value: SqlValueType;

package/lib/runtime/dsl/query/createQueryResolveInfo.d.ts

@@ -1,6 +1,6 @@
 import { BooleanValueExpression } from './query.js';
 import { QueryResolveInfo } from './sql/hydrate.js';
-import { Fields } from "../../field.js";
+import { Fields } from '../../field.js';
 export declare type RelationInfo = {
     table: string;
     on: (parentTableAlias: string, childTableAlias: string) => BooleanValueExpression;

package/lib/runtime/dsl/query/fieldToQuery.d.ts

@@ -1,4 +1,4 @@
 import { Query } from './query.js';
 import { RelationMap } from './createQueryResolveInfo.js';
-import { Fields } from "../../field.js";
+import { Fields } from '../../field.js';
 export declare const fieldToQuery: (tableName: string, fields: Fields, map: RelationMap) => Query;

package/lib/runtime/dsl/query/query.d.ts

@@ -1,4 +1,4 @@
-import { ComparisonOperators } from "../../../db/sql/expression/comparison.js";
+import { ComparisonOperators } from '../../../db/sql/expression/comparison.js';
 export declare enum QueryNodeKind {
     Field = 0,
     Function = 1,
@@ -97,10 +97,11 @@ export declare type Literal = {
     kind: QueryNodeKind.Literal;
     value: string | boolean | number | null;
 };
+export declare type SortDirection = 'ASC' | 'DESC';
 export declare type Sort = {
     kind: QueryNodeKind.Sort;
     field: Field;
-    direction: 'ASC' | 'DESC';
+    direction: SortDirection;
 };
 export declare type QueryNode = Field | Fn | QueryTable | Literal | BooleanValueExpression | Join | Sort;
 export {};

package/lib/runtime/dsl/replaceAliases.js

@@ -56,7 +56,7 @@ export const replaceAliases = (query, tableInfo) => {
     addAlias(query.from);
     const replaceAlias = createAliasReplacer(tableInfo, tableAliases);
     return {
-        select: query.select.map(replaceAlias),
+        select: query.select.map(replaceAlias).filter(it => it.kind !== QueryNodeKind.Field || it.name),
         from: replaceAlias(query.from),
         where: query.where ? replaceAlias(query.where) : undefined,
         sort: query.sort ? query.sort.map(replaceAlias) : undefined,

package/lib/runtime/sasatRepository.d.ts

@@ -2,7 +2,7 @@ import { CommandResponse, DataStoreInfo } from '../index.js';
 import { Fields } from './field.js';
 import { ResultRow } from './dsl/query/sql/hydrate.js';
 import { SQLExecutor } from '../db/connectors/dbClient.js';
-import { BooleanValueExpression, Query } from './dsl/query/query.js';
+import { BooleanValueExpression, Query, Sort } from './dsl/query/query.js';
 export declare type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
 interface Repository<Entity, Creatable, Identifiable> {
     create(entity: Creatable): Promise<Entity>;
@@ -24,8 +24,16 @@ export declare abstract class SasatRepository<Entity, Creatable, Identifiable, E
     create(entity: Creatable): Promise<Entity>;
     update(entity: Identifiable & Partial<Entity>): Promise<CommandResponse>;
     delete(entity: Identifiable): Promise<CommandResponse>;
-    find(fields?: EntityFields, where?: BooleanValueExpression, limit?: number, offset?: number): Promise<EntityResult<Entity, Identifiable>[]>;
-    first(fields?: EntityFields, where?: BooleanValueExpression): Promise<EntityResult<Entity, Identifiable> | null>;
+    first(fields?: EntityFields, option?: {
+        where?: BooleanValueExpression;
+        sort?: Sort[];
+    }): Promise<EntityResult<Entity, Identifiable> | null>;
+    find(fields?: EntityFields, options?: {
+        where?: BooleanValueExpression;
+        sort?: Sort[];
+        limit?: number;
+        offset?: number;
+    }): Promise<EntityResult<Entity, Identifiable>[]>;
     private createIdentifiableExpression;
 }
 export {};

package/lib/runtime/sasatRepository.js

@@ -45,24 +45,25 @@ export class SasatRepository {
         };
         return this.client.rawCommand(deleteToSql(dsl, this.maps.tableInfo));
     }
-    async find(fields, where, limit, offset) {
+    async first(fields, option) {
+        const result = await this.find(fields, option);
+        if (result.length !== 0)
+            return result[0];
+        return null;
+    }
+    async find(fields, options) {
         const field = fields || { fields: this.fields };
         const query = {
             ...fieldToQuery(this.tableName, field, this.maps.relationMap),
-            where,
-            limit,
-            offset,
+            where: options?.where,
+            sort: options?.sort,
+            limit: options?.limit,
+            offset: options?.offset,
         };
         const info = createQueryResolveInfo(this.tableName, field, this.maps.relationMap, this.maps.tableInfo);
         const result = await this.query(appendKeysToQuery(query, this.maps.tableInfo));
         return hydrate(result, info);
     }
-    async first(fields, where) {
-        const result = await this.find(fields, where);
-        if (result.length !== 0)
-            return result[0];
-        return null;
-    }
     createIdentifiableExpression(entity) {
         const expr = this.primaryKeys.map(it => {
             const value = entity[it];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.14.8",
+  "version": "0.14.11",
   "repository": "https://github.com/yanokunpei/sasat.git",
   "author": "yanokunpei <ninian138@gmail.com>",
   "license": "MIT",
@@ -20,6 +20,8 @@
     "prettier": "prettier --write './**/*.ts'",
     "pretest": "yarn resetdb && yarn sasat migrate",
     "test": "env-cmd jest --coverage --silent=false --verbose false",
+    "test:single": "env-cmd jest --silent=false --verbose false",
+    "test:base": "node --experimental-vm-modules node_modules/.bin/jest",
     "resetdb": "docker-compose exec db sh -c \"mysql -u root < /docker-entrypoint-initdb.d/temp.sql\"",
     "prepare": "yarn build",
     "sasat": "yarn env-cmd ts-node-esm ./src/cli/cli.ts",
@@ -29,21 +31,21 @@
     "cac": "6.7.12",
     "chalk": "5.0.1",
     "fs-extra": "^10.0.0",
+    "graphql": "^16.3.0",
     "graphql-subscriptions": "^2.0.0",
     "js-yaml": "^4.0.0",
     "mariadb": "^2.1.5",
-    "mysql": "^2.17.1",
+    "mysql2": "^2.3.3",
     "pluralize": "^8.0.0",
     "prettier": "^2.0.0",
     "sqlstring": "^2.3.1",
-    "typescript": "4.6.3",
-    "graphql": "^16.3.0"
+    "typescript": "4.6.3"
   },
   "devDependencies": {
+    "sasat": "link:./src",
     "@types/fs-extra": "9.0.13",
     "@types/jest": "27.4.1",
     "@types/js-yaml": "4.0.5",
-    "@types/mysql": "2.15.21",
     "@types/node": "16.11.26",
     "@types/pluralize": "0.0.29",
     "@types/prettier": "2.6.0",
@@ -76,31 +78,5 @@
       "pre-commit": "lint-staged"
     }
   },
-  "jest": {
-    "moduleFileExtensions": [
-      "ts",
-      "js"
-    ],
-    "moduleNameMapper": {
-      "^sasat": "<rootDir>/lib"
-    },
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "<rootDir>/lib",
-      "<rootDir>/test"
-    ],
-    "transform": {
-      "^.+\\.(ts|tsx)$": "ts-jest"
-    },
-    "globals": {
-      "ts-jest": {
-        "tsConfig": "tsconfig.json",
-        "diagnostics": true
-      }
-    },
-    "testMatch": [
-      "**/*.test.+(ts|tsx|js)"
-    ]
-  },
   "type": "module"
 }