sasat 0.14.10 → 0.14.13

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';

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/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/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/migration/creators/tableCreator.d.ts

@@ -7,7 +7,7 @@ import { GqlOption } from '../data/gqlOption.js';
 import { DataStore } from '../dataStore.js';
 export interface TableBuilder {
     column(columnName: string): ColumnCreator;
-    references(reference: Reference): TableBuilder;
+    references(reference: Reference, notNull: boolean): TableBuilder;
     setPrimaryKey(...columnNames: string[]): TableBuilder;
     addUniqueKey(...columnNames: string[]): TableBuilder;
     createdAt(): TableBuilder;
@@ -23,7 +23,7 @@ export declare class TableCreator implements TableBuilder {
     column(name: string): ColumnCreator;
     addColumn(column: ColumnBuilder): void;
     addUniqueKey(...columnNames: string[]): TableBuilder;
-    references(ref: Reference): TableBuilder;
+    references(ref: Reference, notNull?: boolean): TableBuilder;
     setPrimaryKey(...columnNames: string[]): TableBuilder;
     create(): TableHandler;
     createdAt(): TableBuilder;

package/lib/migration/creators/tableCreator.js

@@ -19,8 +19,8 @@ export class TableCreator {
         this.table.addUniqueKey(...columnNames);
         return this;
     }
-    references(ref) {
-        this.table.addReferences(ref);
+    references(ref, notNull = true) {
+        this.table.addReferences(ref, undefined, notNull);
         return this;
     }
     setPrimaryKey(...columnNames) {

package/lib/migration/serializable/table.d.ts

@@ -29,7 +29,7 @@ export declare class TableHandler implements Table {
     addColumn(column: BaseColumn, isPrimary?: boolean, isUnique?: boolean): void;
     dropColumn(columnName: string): void;
     serialize(): SerializedTable;
-    addReferences(ref: Reference, fieldName?: string): this;
+    addReferences(ref: Reference, fieldName?: string, notNull?: boolean): this;
     private getIndexConstraintName;
     addIndex(...columns: string[]): this;
     removeIndex(...columns: string[]): this;

package/lib/migration/serializable/table.js

@@ -56,7 +56,7 @@ export class TableHandler {
             gqlOption: this.gqlOption,
         };
     }
-    addReferences(ref, fieldName) {
+    addReferences(ref, fieldName, notNull = true) {
         const target = this.store.table(ref.targetTable).column(ref.targetColumn);
         const targetData = target.serialize();
         const data = {
@@ -64,7 +64,7 @@ export class TableHandler {
             hasReference: true,
             fieldName: fieldName || ref.columnName,
             columnName: ref.columnName,
-            notNull: true,
+            notNull,
             default: undefined,
             zerofill: false,
             autoIncrement: false,
@@ -109,7 +109,7 @@ export class TableHandler {
                 rows.push(`UNIQUE KEY (${it.join(',')})`);
         });
         rows.push(...this._columns
-            .filter(it => it.isReference())
+            .filter(it => it.isReference() && it.data.reference.noFKey)
             .map(it => {
             const ref = it;
             return referenceToSql(ref.getConstraintName(), ref.data.reference);

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

@@ -28,6 +28,7 @@ export interface Reference {
     relationName?: string;
     onUpdate?: ForeignKeyReferentialAction;
     onDelete?: ForeignKeyReferentialAction;
+    noFKey?: boolean;
 }
 export declare const referenceToSql: (constraintName: string, ref: Reference) => string;
 export interface SerializedReferenceColumn extends SerializedColumnBase {

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

@@ -1,6 +1,6 @@
-import { BooleanValueExpression, Literal, IsNullExpression, Value, ParenthesisExpression, Field, BetweenExpression, InExpression, ComparisonExpression, Fn, QueryTable, Join, JoinType } 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?: JoinType | 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/query/query.d.ts

@@ -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/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.10",
+  "version": "0.14.13",
   "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",
@@ -37,9 +39,10 @@
     "pluralize": "^8.0.0",
     "prettier": "^2.0.0",
     "sqlstring": "^2.3.1",
-    "typescript": "4.6.3"
+    "typescript": "4.7.3"
   },
   "devDependencies": {
+    "sasat": "link:./src",
     "@types/fs-extra": "9.0.13",
     "@types/jest": "27.4.1",
     "@types/js-yaml": "4.0.5",
@@ -51,7 +54,7 @@
     "@typescript-eslint/parser": "5.19.0",
     "apollo-server": "3.6.7",
     "env-cmd": "10.1.0",
-    "eslint": "8.13.0",
+    "eslint": "8.17.0",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-prettier": "4.0.0",
     "husky": "7.0.4",
@@ -75,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"
 }