sasat 0.19.32 → 0.19.34

package/lib/generatorv2/codegen/ts/generateAutoGeneratedDatasource.js

@@ -71,12 +71,11 @@ const makeDefaultValueMethod = (node) => {
         .modifiers(tsg.methodModifiers().protected());
 };
 const makeFindMethods = (node) => {
-    const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+    const qExpr = tsg.identifier('qe').importFrom('sasat');
     return node.findMethods.map(it => {
         const bve = it.params.flatMap(it => {
             if (!it.entity)
                 return qExpr
-                    .property('conditions')
                     .property('eq')
                     .call(qExpr
                     .property('field')
@@ -85,7 +84,6 @@ const makeFindMethods = (node) => {
                     .call(tsg.identifier(it.fieldName.toString())));
             return it.fields.map(field => {
                 return qExpr
-                    .property('conditions')
                     .property('eq')
                     .call(qExpr
                     .property('field')
@@ -96,8 +94,11 @@ const makeFindMethods = (node) => {
         });
         const body = [
             tsg.variable('const', 'tableName', tsg.identifier('fields?.tableAlias || "t0"')),
-            tsg.return(tsg.identifier(it.isArray ? 'this.find' : 'this.first').call(tsg.identifier('fields'), tsg.object().addProperties(tsg.spreadAssign(tsg.identifier('options')), tsg.propertyAssign('where', qExpr
-                .property('conditions')
+            tsg.return(tsg
+                .identifier(it.isArray ? 'this.find' : 'this.first')
+                .call(tsg.identifier('fields'), tsg
+                .object()
+                .addProperties(tsg.spreadAssign(tsg.identifier('options')), tsg.propertyAssign('where', qExpr
                 .property('and')
                 .call(...bve, tsg.identifier('options?').property('where')))), tsg.identifier('context'))),
         ];

package/lib/generatorv2/codegen/ts/generateQueryResolver.js

@@ -119,7 +119,7 @@ const makeTypeArgs = (args) => {
         tsg.typeLiteral(args.map(it => tsg.propertySignature(it.name, getType(it, false)))),
     ];
 };
-const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const qExpr = tsg.identifier('qe').importFrom('sasat');
 const makeGQLQueryBody = (entity, query) => {
     const fields = tsg.variable('const', 'fields', tsg
         .identifier('gqlResolveInfoToField')
@@ -128,7 +128,6 @@ const makeGQLQueryBody = (entity, query) => {
         .as(makeTypeRef(entity.name, 'fields', 'GENERATED')));
     const where = query.conditions && query.conditions.length !== 0
         ? tsg.variable('const', 'where', qExpr
-            .property('conditions')
             .property('and')
             .call(...(query.conditions || []).map(makeQueryConditionExpr)))
         : null;

package/lib/generatorv2/codegen/ts/relationMap/makeJoinConditionValue.js

@@ -2,7 +2,7 @@ import { tsg } from '../../../../tsg/index.js';
 import { makeThrowExpressions } from './makeNoContexError.js';
 import { makeConditionValueQExpr } from '../scripts/makeConditonValueExpr.js';
 import { nonNullable } from '../../../../runtime/util.js';
-const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const qExpr = tsg.identifier('qe').importFrom('sasat');
 const parentTableAlias = 'parentTableAlias';
 const childTableAlias = 'childTableAlias';
 export const makeJoinConditionValueQExpr = (node, cv) => {
@@ -53,12 +53,10 @@ const makeConditionExpr = (entity, condition) => {
     }
     if (condition.operator === 'BETWEEN') {
         return qExpr
-            .property('conditions')
             .property('between')
             .call(makeJoinConditionValueQExpr(entity, condition.left), ...makeRangeCondition(entity, condition.right));
     }
     return qExpr
-        .property('conditions')
         .property('comparison')
         .call(makeJoinConditionValueQExpr(entity, condition.left), tsg.string(condition.operator), makeJoinConditionValueQExpr(entity, condition.right));
 };
@@ -67,7 +65,6 @@ export const makeJoinConditionValue = (node, ref) => {
     return tsg.propertyAssign('condition', tsg.arrowFunc([tsg.parameter(arg.toString())], tsg.typeRef('BooleanValueExpression').importFrom('sasat'), tsg.block(...ref.joinCondition
         .flatMap(it => makeThrowExpressions(it))
         .filter(nonNullable), tsg.return(qExpr
-        .property('conditions')
         .property('and')
         .call(...ref.joinCondition.map(it => makeConditionExpr(node, it)))))));
 };

package/lib/generatorv2/codegen/ts/scripts/makeConditonValueExpr.js

@@ -1,5 +1,5 @@
 import { tsg } from '../../../../tsg/index.js';
-const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const qExpr = tsg.identifier('qe').importFrom('sasat');
 export const makeConditionValueQExpr = (cv) => {
     const arg = tsg.identifier('arg');
     const context = arg.property('context?');

package/lib/generatorv2/codegen/ts/scripts/makeQueryConditionExpr.js

@@ -1,15 +1,13 @@
 import { tsg } from '../../../../tsg/index.js';
 import { makeConditionValueQExpr } from './makeConditonValueExpr.js';
-const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const qExpr = tsg.identifier('qe').importFrom('sasat');
 export const makeQueryConditionExpr = (condition) => {
     if (condition.kind === 'between') {
         return qExpr
-            .property('conditions')
             .property('between')
             .call(makeConditionValueQExpr(condition.left), makeConditionValueQExpr(condition.begin), makeConditionValueQExpr(condition.end));
     }
     return qExpr
-        .property('conditions')
         .property('comparison')
         .call(makeConditionValueQExpr(condition.left), tsg.string(condition.operator), makeConditionValueQExpr(condition.right));
 };

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

@@ -1,4 +1,4 @@
-import { BetweenExpression, BooleanValueExpression, ComparisonExpression, Field, Fn, Identifier, InExpression, IsNullExpression, Join, JoinType, Literal, ParenthesisExpression, Query, QueryTable, Sort, SortDirection, Value } from './query/query.js';
+import { BetweenExpression, BooleanValueExpression, ComparisonExpression, ExistsExpression, Field, Fn, Identifier, InExpression, IsNullExpression, Join, JoinType, Literal, ParenthesisExpression, Query, QueryTable, RawExpression, Sort, SortDirection, Value } from './query/query.js';
 import { ComparisonOperators } from '../../db/sql/expression/comparison.js';
 type StrOrNum = string | number;
 type ValueType = string | boolean | number | null;
@@ -13,6 +13,7 @@ export declare const QExpr: {
     readonly sort: (field: Field | Fn, direction?: SortDirection) => Sort;
     readonly order: (field: Field | Fn, direction?: SortDirection) => Sort;
     readonly ident: (identifier: string) => Identifier;
+    readonly raw: (sql: string) => RawExpression;
     readonly simpleWhere: (tableNameOrAlias: string, where: {
         [field: string]: ValueType | [ComparisonOperators, ValueType];
     }, isOr?: boolean) => BooleanValueExpression;
@@ -31,11 +32,12 @@ export declare const QExpr: {
     readonly notStatsWiths: (left: Value, right: string) => BooleanValueExpression;
     readonly endsWiths: (left: Value, right: string) => BooleanValueExpression;
     readonly notEndsWiths: (left: Value, right: string) => BooleanValueExpression;
-    readonly In: (left: Value, values: StrOrNum[]) => BooleanValueExpression;
-    readonly notIn: (left: Value, values: (string | number)[]) => InExpression;
+    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];
@@ -55,11 +57,12 @@ export declare const QExpr: {
         notStatsWiths: (left: Value, right: string) => BooleanValueExpression;
         endsWiths: (left: Value, right: string) => BooleanValueExpression;
         notEndsWiths: (left: Value, right: string) => BooleanValueExpression;
-        In: (left: Value, values: StrOrNum[]) => BooleanValueExpression;
-        notIn: (left: Value, values: (string | number)[]) => InExpression;
+        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;
     };
 };
 export {};

package/lib/runtime/dsl/factory.js

@@ -38,14 +38,22 @@ const paren = (expression) => ({
     kind: QueryNodeKind.Parenthesis,
     expression,
 });
-const In = (left, values) => {
-    if (values.length === 0)
-        return conditions.eq(literal(0), literal(1));
+const In = (left, right) => {
+    if (Array.isArray(right)) {
+        if (right.length === 0)
+            return conditions.eq(literal(0), literal(1));
+        return {
+            kind: QueryNodeKind.InExpr,
+            left,
+            operator: 'IN',
+            right: right.map(literal),
+        };
+    }
     return {
         kind: QueryNodeKind.InExpr,
         left,
         operator: 'IN',
-        right: values.map(literal),
+        query: right,
     };
 };
 const notIn = (left, values) => ({
@@ -74,6 +82,14 @@ const simpleWhere = (tableNameOrAlias, where, isOr = false) => {
         return conditions.eq(fe, literal(value));
     }));
 };
+const exists = (query) => ({
+    kind: QueryNodeKind.Exists,
+    query,
+});
+const raw = (sql) => ({
+    kind: QueryNodeKind.Raw,
+    expr: sql,
+});
 const conditions = {
     simpleWhere,
     and,
@@ -96,6 +112,7 @@ const conditions = {
     between,
     isNull: isNull(false),
     isNotNull: isNull(true),
+    exists,
 };
 const table = (name, joins, alias) => ({
     kind: QueryNodeKind.Table,
@@ -143,4 +160,5 @@ export const QExpr = {
     sort,
     order: sort,
     ident,
+    raw,
 };

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

@@ -13,7 +13,9 @@ export declare enum QueryNodeKind {
     ContainsExpr = 10,
     Literal = 11,
     Sort = 12,
-    Identifier = 13
+    Identifier = 13,
+    Exists = 14,
+    Raw = 15
 }
 export type LockMode = 'FOR UPDATE' | 'FOR SHARE';
 export type Query = {
@@ -62,7 +64,15 @@ export type ParenthesisExpression = {
     kind: QueryNodeKind.Parenthesis;
     expression: BooleanValueExpression;
 };
-export type BooleanValueExpression = CompoundExpression | ComparisonExpression | IsNullExpression | ParenthesisExpression | InExpression | BetweenExpression | ContainsExpression;
+export type RawExpression = {
+    kind: QueryNodeKind.Raw;
+    expr: string;
+};
+export type ExistsExpression = {
+    kind: QueryNodeKind.Exists;
+    query: Query | RawExpression;
+};
+export type BooleanValueExpression = CompoundExpression | ComparisonExpression | IsNullExpression | ParenthesisExpression | InExpression | BetweenExpression | ContainsExpression | ExistsExpression;
 export type IsNullExpression = {
     kind: QueryNodeKind.IsNullExpr;
     expr: Value;
@@ -93,8 +103,11 @@ export type InExpression = {
     kind: QueryNodeKind.InExpr;
     left: Value;
     operator: 'IN' | 'NOT IN';
+} & ({
+    query: Query | RawExpression;
+} | {
     right: Value[];
-};
+});
 export type BetweenExpression = {
     kind: QueryNodeKind.BetweenExpr;
     left: Value;
@@ -113,7 +126,7 @@ export type Literal = {
 export type SortDirection = 'ASC' | 'DESC';
 export type Sort = {
     kind: QueryNodeKind.Sort;
-    field: Field | Fn;
+    field: Field | Fn | Identifier;
     direction?: SortDirection;
 };
 export type QueryNode = Field | Fn | QueryTable | Literal | BooleanValueExpression | Join | Sort;

package/lib/runtime/dsl/query/query.js

@@ -14,5 +14,7 @@ export var QueryNodeKind;
     QueryNodeKind[QueryNodeKind["Literal"] = 11] = "Literal";
     QueryNodeKind[QueryNodeKind["Sort"] = 12] = "Sort";
     QueryNodeKind[QueryNodeKind["Identifier"] = 13] = "Identifier";
+    QueryNodeKind[QueryNodeKind["Exists"] = 14] = "Exists";
+    QueryNodeKind[QueryNodeKind["Raw"] = 15] = "Raw";
 })(QueryNodeKind || (QueryNodeKind = {}));
 export const NO_ALIAS = '__SASAT_NO_ALIAS';

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

@@ -1,4 +1,4 @@
-import { BetweenExpression, BooleanValueExpression, ComparisonExpression, CompoundExpression, ContainsExpression, Field, Fn, Identifier, InExpression, IsNullExpression, Join, Literal, ParenthesisExpression, QueryTable, SelectExpr, Sort, Value } from '../query.js';
+import { BetweenExpression, BooleanValueExpression, ComparisonExpression, CompoundExpression, ContainsExpression, ExistsExpression, Field, Fn, Identifier, InExpression, IsNullExpression, Join, Literal, ParenthesisExpression, Query, QueryTable, RawExpression, SelectExpr, Sort, Value } from '../query.js';
 export declare const SELECT_ALIAS_SEPARATOR = "__";
 export declare const Sql: {
     select: (expr: SelectExpr) => string;
@@ -18,6 +18,8 @@ export declare const Sql: {
     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;
 };

package/lib/runtime/dsl/query/sql/nodeToSql.js

@@ -42,9 +42,13 @@ export const Sql = {
         };
         return `${Sql.value(expr.left)} ${operator} ${SqlString.escape(val(expr.right, expr.type))}`;
     },
-    in: (expr) => `${Sql.value(expr.left)} ${expr.operator} (${expr.right
-        .map(Sql.value)
-        .join(', ')})`,
+    in: (expr) => {
+        if ('right' in expr)
+            return `${Sql.value(expr.left)} ${expr.operator} (${expr.right
+                .map(Sql.value)
+                .join(', ')})`;
+        return `${Sql.value(expr.left)} ${expr.operator} (${Sql.queryOrRaw(expr.query)})`;
+    },
     comparison: (expr) => `${Sql.value(expr.left)}  ${expr.operator} ${Sql.value(expr.right)}`,
     compound: (expr) => `${Sql.booleanValue(expr.left)}  ${expr.operator} ${Sql.booleanValue(expr.right)}`,
     isNull: (expr) => `${Sql.value(expr.expr)} ${expr.isNot ? 'IS NOT NULL' : 'IS NULL'}`,
@@ -77,15 +81,33 @@ export const Sql = {
                 return Sql.in(expr);
             case QueryNodeKind.IsNullExpr:
                 return Sql.isNull(expr);
+            case QueryNodeKind.Exists:
+                return Sql.exists(expr);
         }
     },
+    exists: (expr) => {
+        return `EXISTS (${Sql.queryOrRaw(expr.query)})`;
+    },
     sort: (expr) => {
-        const f = expr.field.kind === QueryNodeKind.Field
-            ? Sql.fieldInCondition(expr.field)
-            : Sql.fn(expr.field);
+        const field = () => {
+            switch (expr.field.kind) {
+                case QueryNodeKind.Field:
+                    return Sql.fieldInCondition(expr.field);
+                case QueryNodeKind.Identifier:
+                    return Sql.identifier(expr.field);
+                default:
+                    return Sql.fn(expr.field);
+            }
+        };
         if (expr.direction)
-            return `${f} ${expr.direction === 'DESC' ? 'DESC' : 'ASC'}`;
-        return f;
+            return `${field()} ${expr.direction === 'DESC' ? 'DESC' : 'ASC'}`;
+        return field();
     },
     sorts: (sorts) => sorts.map(Sql.sort).join(', '),
+    queryOrRaw: (expr) => {
+        if ('kind' in expr) {
+            return expr.expr;
+        }
+        return queryToSql(expr);
+    },
 };

package/lib/runtime/pagingOption.d.ts

@@ -1,4 +1,4 @@
-import { BooleanValueExpression, PagingOption } from '../index.js';
+import { BooleanValueExpression, ListQueryOption } from '../index.js';
 import { Sort } from './dsl/query/query.js';
 type DsPagingOption = {
     numberOfItem: number;
@@ -6,5 +6,5 @@ type DsPagingOption = {
     offset?: number;
     sort?: Sort[];
 };
-export declare const pagingOption: (option: PagingOption) => DsPagingOption;
+export declare const pagingOption: (option: ListQueryOption) => DsPagingOption;
 export {};

package/lib/runtime/sasatDBDatasource.d.ts

@@ -2,7 +2,7 @@ import { CommandResponse, RelationMap } from '../index.js';
 import { Fields } from './field.js';
 import { SQLExecutor, SqlValueType } from '../db/connectors/dbClient.js';
 import { TableInfo } from './dsl/query/createQueryResolveInfo.js';
-import { BooleanValueExpression, LockMode, Sort } from './dsl/query/query.js';
+import { BooleanValueExpression, Join, LockMode, Sort } from './dsl/query/query.js';
 import { PagingOption } from './sql/runQuery.js';
 export type EntityType = Record<string, SqlValueType>;
 export type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
@@ -16,6 +16,7 @@ export type ListQueryOption = {
     offset?: number;
     order?: string;
     asc?: boolean;
+    join?: Join[];
 };
 export type QueryOptions = {
     where?: BooleanValueExpression;

package/lib/runtime/sasatDBDatasource.js

@@ -1,4 +1,4 @@
-import { getDbClient, QExpr } from '../index.js';
+import { getDbClient, qe } from '../index.js';
 import { createQueryResolveInfo, } from './dsl/query/createQueryResolveInfo.js';
 import { createToSql, deleteToSql, updateToSql, } from './dsl/mutation/mutation.js';
 import { createPagingFieldQuery, createQuery, } from './sql/runQuery.js';
@@ -96,9 +96,9 @@ export class SasatDBDatasource {
             const value = entity[it];
             if (!value)
                 throw new Error(`field ${it} is required`);
-            return QExpr.conditions.eq(QExpr.field(this.tableName, this.tableInfo[this.tableName].columnMap[it]), QExpr.value(value));
+            return qe.eq(qe.field(this.tableName, this.tableInfo[this.tableName].columnMap[it]), qe.value(value));
         });
-        return QExpr.conditions.and(...expr);
+        return qe.and(...expr);
     }
     getRelationMap() {
         return this.relationMap[this.tableName];

package/lib/runtime/sql/runQuery.d.ts

@@ -1,15 +1,16 @@
-import { BooleanValueExpression, Query, Sort } from '../dsl/query/query.js';
+import { BooleanValueExpression, Join, Query, Sort } from '../dsl/query/query.js';
 import { SQLExecutor } from '../../db/connectors/dbClient.js';
 import { RelationMap, TableInfo } from '../dsl/query/createQueryResolveInfo.js';
 import { Fields } from '../field.js';
 import { QueryResolveInfo } from '../dsl/query/sql/hydrate.js';
-import { ListQueryOption, QueryOptions } from '../sasatDBDatasource.js';
+import { QueryOptions } from '../sasatDBDatasource.js';
 export declare const createQuery: (baseTableName: string, fields: Fields<unknown>, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: unknown) => Query;
 export type PagingOption = {
     numberOfItem: number;
     where?: BooleanValueExpression;
     offset?: number;
     sort?: Sort[];
+    join?: Join[];
 };
 export declare const createPagingInnerQuery: (tableName: string, tableAlias: string, fields: Fields<unknown>, option: PagingOption, tableInfo: TableInfo, relationMap: RelationMap) => Query;
 export declare const runQuery: (client: SQLExecutor, query: Query, resolveInfo: QueryResolveInfo) => Promise<unknown[]>;
@@ -19,9 +20,7 @@ type CreatePagingFieldQueryArg = {
     tableInfo: TableInfo;
     relationMap: RelationMap;
     queryOption?: QueryOptions;
-    pagingOption: ListQueryOption & {
-        where?: BooleanValueExpression;
-    };
+    pagingOption: PagingOption;
     context?: unknown;
 };
 export declare const createPagingFieldQuery: ({ baseTableName, fields, queryOption, pagingOption, tableInfo, relationMap, context, }: CreatePagingFieldQueryArg) => Query;

package/lib/runtime/sql/runQuery.js

@@ -27,7 +27,7 @@ export const createQuery = (baseTableName, fields, options, tableInfo, relationM
             const rel = relationMap[tableName][relationName];
             if (!rel)
                 return undefined;
-            return QExpr.join(resolveFields(rel.table, table), QExpr.conditions.and(rel.condition({
+            return QExpr.join(resolveFields(rel.table, table), QExpr.and(rel.condition({
                 parentTableAlias: tableAlias,
                 childTableAlias: table.tableAlias || 't' + current,
                 context,
@@ -54,7 +54,7 @@ export const createPagingInnerQuery = (tableName, tableAlias, fields, option, ta
                 .filter(it => notTypeName(it) && map[it])
                 .map(it => map[it] || it),
         ]).map(it => QExpr.field(tableAlias, it)),
-        from: QExpr.table(tableName, [], tableAlias),
+        from: QExpr.table(tableName, option.join || [], tableAlias),
         limit: option.numberOfItem,
         offset: option.offset,
         where: option.where,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.19.32",
+  "version": "0.19.34",
   "repository": "https://github.com/nin138/sasat.git",
   "author": "nin138 <ninian138@gmail.com>",
   "license": "MIT",