@elyx-code/project-logic-tree 0.0.6278 → 0.0.6280

package/dist/tree/state/project/project.d.ts

@@ -30,6 +30,7 @@ export interface UUIDModule {
     fromUUID: (uuid: string) => string;
 }
 export declare enum ProjectStateEvents {
+    PROJECT_INITIALIZED = "project-initialized",
     DEFINITION_ENTITY_ADDED = "definition-entity-added",
     DEFINITION_ENTITY_REMOVED = "definition-entity-removed",
     DEFINITION_ENTITY_UPDATED = "definition-entity-updated",
@@ -99,6 +100,7 @@ export declare class ProjectState extends CombinedVersionedEvents implements IPr
         success: boolean;
     }>) | null;
     onAddChangeSetCallback: ((changeSet: ChangeSet, undoableStackValueIndex: number) => void) | null;
+    onDiscardChangeSetCallback: ((changeSet: ChangeSet) => void) | null;
     onRequestActiveValueCallback: ((valueOwner: EntityWithValueState) => LiteralValueState | null) | null;
     constructor(initialData: IProject | IProjectTransfer);
     static sessionAuthor: string;
@@ -132,6 +134,7 @@ export declare class ProjectState extends CombinedVersionedEvents implements IPr
         success: boolean;
     }>): Promise<void>;
     onAddChangeSet(callback: (changeSet: ChangeSet, undoableStackValueIndex: number) => void): void;
+    onDiscardChangeSet(callback: (changeSet: ChangeSet) => void): void;
     closeChangeSet(changeSet: ChangeSet): Promise<void>;
     toLatestChangeSet(author: string, timestamp: string, // ISO 8601 format
     self: UserManagedEntityState | null, autoclose?: boolean, autoCloseActionName?: string): ChangeSet;
@@ -160,7 +163,7 @@ export declare class ProjectState extends CombinedVersionedEvents implements IPr
     recursiveCaptureUpstreamVersions(_sharedTimestamp: null | string): IChangeSet<ProjectState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ProjectState>>;
     hydrateAncestors(): IChangeSet<ProjectState>;
-    afterAllChildrenInitialized(_changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ProjectState>;
     addSelfToProject(_changeSet: ChangeSet | null): IChangeSet<ProjectState>;
     get instancesList(): EntityState[];
     isOperationDeclaration(entity: ActionDescriptorState): boolean;

package/dist/tree/state/search/index.d.ts

@@ -1,2 +1,4 @@
 export * from './search';
 export * as searchValidation from './validation/logic-validation';
+export * from './query/hydrate';
+export * from './query/search-statement-state';

package/dist/tree/state/search/query/hydrate.d.ts

@@ -0,0 +1,113 @@
+import { SelectStmt, Program, FromClause, TablesampleExpr, JoinExpr, LimitClause, OrderByClause, Keyword, PivotExpr, UnpivotExpr, ForSystemTimeAsOfExpr, TableFactor, SelectClause, WhereClause, Expr, PostgresqlOperatorExpr, BinaryExpr, Program as SQLAST } from 'sql-parser-cst';
+import { AggregationStatement, AggregationStatementType, ColumnRef, SearchStatementState, SortStatement, WhereStatement, WhereStatementOperator } from './search-statement-state';
+import { ProjectState } from '../../project';
+import { DefinitionEntityState } from '../../definition-entity';
+import { SearchState } from '../search';
+import { PropertyState } from '../../property';
+
+export declare const FORBIDDEN_SQL_KEYWORDS: string[];
+export interface IShallowColumnMapping {
+    from: string;
+    to: string;
+}
+export interface IColumnMapping {
+    as: string;
+    column: {
+        columnName: string;
+        property: PropertyState | null;
+    };
+}
+export interface Table {
+    entity: DefinitionEntityState;
+    columns: {
+        columnName: string;
+        property: PropertyState | null;
+    }[];
+}
+type SupportedOperators = string | PostgresqlOperatorExpr | Keyword<'IS'> | [Keyword<'IS'>, Keyword<'NOT'>] | [Keyword<'IS'>, Keyword<'DISTINCT'>, Keyword<'FROM'>] | [Keyword<'IS'>, Keyword<'NOT'>, Keyword<'DISTINCT'>, Keyword<'FROM'>] | Keyword<'IN'> | [Keyword<'NOT'>, Keyword<'IN'>] | Keyword<'LIKE' | 'RLIKE' | 'ILIKE' | 'GLOB' | 'MATCH'> | [Keyword<'NOT'>, Keyword<'LIKE' | 'RLIKE' | 'ILIKE' | 'GLOB' | 'MATCH'>];
+export declare function loadProjectDatasources(project: ProjectState): DefinitionEntityState[];
+export declare function getSelectStatementFromProgram(program: Program): SelectStmt | null;
+export declare function getFromClauseFromSelectStatement(selectStatement: SelectStmt): FromClause | null;
+export declare function getNestedFromSubqueryFromSelectStatement(selectStatement: SelectStmt): {
+    selectStatement: SelectStmt;
+    as: string;
+} | null;
+export declare function getMainSourceNameFromFromClauseExpr(fromExpr: JoinExpr | PivotExpr | UnpivotExpr | TablesampleExpr | ForSystemTimeAsOfExpr | TableFactor, parentExpr?: JoinExpr): {
+    type: 'table';
+    name: string;
+    as: string;
+} | null;
+export declare function getMainSourceNameFromSelectStatement(selectStatement: SelectStmt): {
+    type: 'table';
+    name: string;
+    as: string;
+} | null;
+export declare function getMainSourceFromSelectStatement(selectStatement: SelectStmt): {
+    type: 'table';
+    name: string;
+    as: string;
+} | {
+    type: 'query';
+    subquery: SelectStmt;
+    as: string;
+} | null;
+export declare function getSelectClauseFromSelectStatement(selectStatement: SelectStmt): SelectClause;
+export declare function fromSelectClauseColumnsToColumnMappings(selectClause: SelectClause, objectName?: string): IShallowColumnMapping[];
+export declare function getSelectionsConfigFromSelectClause(selectClause: SelectClause): {
+    columns: {
+        name: string;
+        source: string | null;
+    }[];
+    globalSelectAll: boolean;
+    scopedSelectAll: string[];
+} | null;
+export declare function getJoinTypeFromJoinClause(joinClause: JoinExpr): AggregationStatementType;
+export declare function getJoinTableFromJoinClause(joinClause: JoinExpr): string;
+export declare function fromSqlOperatorsExprToComparisonOperator(operator: SupportedOperators): WhereStatementOperator | 'not' | null;
+export declare function fromWhereBinaryExprToComparisonOperator(binaryExpr: BinaryExpr): WhereStatementOperator | null;
+export declare function fromWhereBinaryExprToAndOrOperatorValue(whereExpr: BinaryExpr): 'AND' | 'OR' | null;
+export declare function flattenBinaryExprComparisonsToWhereStatements(whereExpr: BinaryExpr, parent: WhereStatement, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): {
+    ands: WhereStatement[];
+    ors: WhereStatement[];
+};
+export declare function fromWhereExprToWhereStatement(whereExpr: Expr, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): WhereStatement | null;
+export declare function getJoinOnSpecificationAsWhereStatementFromJoinExpr(joinClause: JoinExpr, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, debug?: boolean): WhereStatement | null;
+export declare function flattenJoinExprIntoAggregationStatementsSync(joinExpr: JoinExpr, parentQuery: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, helpers?: {
+    onDescribeTable?: (tableName: string) => Table | null;
+}, debug?: boolean): {
+    aggregations: AggregationStatement[];
+    columnMappings: IColumnMapping[];
+    errors: {
+        entity: 'column' | 'table';
+        code: 'not-found';
+        name: string;
+    }[];
+};
+export declare function getAggregationStatementsFromSelectStatementSync(selectStatement: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState, helpers?: {
+    onDescribeTable?: (tableName: string) => Table | null;
+}): {
+    aggregations: AggregationStatement[];
+    columnMappings: IColumnMapping[];
+    errors: {
+        entity: 'column' | 'table';
+        code: 'not-found';
+        name: string;
+    }[];
+};
+export declare function fromSelectClauseToLiteralValueSelections(selectClause: SelectClause, state: SearchStatementState, _debug?: boolean): ColumnRef[];
+export declare function getWhereClauseFromSelectStatement(selectStatement: SelectStmt): WhereClause | null;
+export declare function getWhereStatementsFromSelectStatement(selectStatement: SelectStmt, scopeColumns: ColumnRef[], state: SearchStatementState, project: ProjectState): WhereStatement | null;
+export declare function getLimitClauseFromSelectStatement(selectStatement: SelectStmt): LimitClause | null;
+export declare function getRawOffetFromLimitClause(limitClause: LimitClause | null): number;
+export declare function getRawLimitFromLimitClause(limitClause: LimitClause | null): number | null;
+export declare function getOrderByClauseFromSelectStatement(selectStatement: SelectStmt): OrderByClause | null;
+export declare function fromOrderByClauseToSortStatements(orderByClause: OrderByClause, _selectStatement: SelectStmt, _allColumns: IColumnMapping[], state: SearchStatementState): SortStatement[];
+export declare function hydrateSearchStatementState(ast: SQLAST | SelectStmt, project: ProjectState, entity?: SearchState | null, debug?: boolean): {
+    state: SearchStatementState | null;
+    errors: {
+        entity: 'column' | 'table';
+        code: 'not-found';
+        name: string;
+    }[];
+};
+export {};

package/dist/tree/state/search/query/search-statement-state.d.ts

@@ -0,0 +1,233 @@
+import { Program as SQLAST } from 'sql-parser-cst';
+import { DefinitionEntityState, InputMapState, PropertyState } from '../..';
+
+export declare function resolveAreThereConflictingColumnsInSelectAll(allColumnsSelector: AllColumnsSelector | null): boolean;
+export declare enum SearchStatementNodeType {
+    SearchStatement = "search-statement",
+    NestedSearchStatement = "nested-search-statement",
+    DataSource = "data-source",
+    ColumnRef = "column-ref",
+    ValueRef = "value-ref",
+    LiteralValue = "literal-value",
+    WhereStatement = "where-statement",
+    AggregationStatement = "aggregation-statement",
+    SortStatement = "sort-statement",
+    AllColumnsSelector = "all-columns-selector"
+}
+export interface ISearchNode {
+    type: SearchStatementNodeType;
+}
+export declare enum AggregationStatementType {
+    Inner = "inner",
+    Left = "left",
+    Right = "right",
+    Full = "full",
+    Cross = "cross",
+    Self = "self",
+    Natural = "natural"
+}
+interface IDataSource {
+    entity: DefinitionEntityState | null;
+    query: NestedSearchStatement | null;
+    aggregation: AggregationStatement | null;
+    sourceType: DataSourceType | null;
+    as: string;
+}
+export declare class AggregationStatement implements ISearchNode {
+    owner: SearchStatementState;
+    dataSource: DataSource | null;
+    joinType: AggregationStatementType;
+    on: WhereStatement | null;
+    as: string | null;
+    constructor(owner: SearchStatementState);
+    get type(): SearchStatementNodeType.AggregationStatement;
+    get id(): string;
+    get columns(): ColumnRef[];
+    get isValid(): boolean;
+    get selections(): (ColumnRef | AllColumnsSelector)[];
+    get selectedColumns(): ColumnRef[];
+    get primaryKeys(): ColumnRef[];
+    get primaryKey(): ColumnRef | null;
+    setDataSource(dataSource: DataSource): void;
+    removeDataSource(): void;
+    editDataSource(dataSource: DataSource): void;
+}
+export declare enum SearchLiteralValueType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Null = "null",
+    Date = "date"
+}
+export declare class LiteralValue implements ISearchNode {
+    owner: SearchStatementState;
+    valueType: SearchLiteralValueType;
+    value: string | number | boolean | null | Date;
+    _id: string;
+    constructor(owner: SearchStatementState);
+    get type(): SearchStatementNodeType.LiteralValue;
+    get id(): string;
+    toQuery(): string;
+}
+export declare enum WhereStatementOperator {
+    Like = "like",
+    NotLike = "not-like",
+    In = "in",
+    Equal = "=",
+    Between = "-",
+    BiggerThan = ">",
+    SmallerThan = "<",
+    BiggerThanOrEqualTo = ">=",
+    SmallerThanOrEqualTo = "<=",
+    NotEqual = "!="
+}
+export declare function whereStatementOperatorToSQL(operator: WhereStatementOperator): 'LIKE' | 'NOT LIKE' | 'IS NOT' | 'BETWEEN' | 'IN' | WhereStatementOperator.BiggerThan | WhereStatementOperator.SmallerThan | WhereStatementOperator.BiggerThanOrEqualTo | WhereStatementOperator.SmallerThanOrEqualTo;
+export declare class WhereStatement implements ISearchNode {
+    owner: SearchStatementState;
+    parent: WhereStatement | null;
+    and: WhereStatement[];
+    or: WhereStatement[];
+    left: ColumnRef | InputMapState | LiteralValue | null;
+    operator: WhereStatementOperator | null;
+    right: ColumnRef | InputMapState | LiteralValue | null;
+    _id: string;
+    constructor(owner: SearchStatementState, parent?: WhereStatement);
+    get type(): SearchStatementNodeType.WhereStatement;
+    get isValid(): boolean;
+    get id(): string;
+    removeDataSource(dataSource: DataSource): void;
+    toQuery(): string;
+    sanitize(): void;
+    removeFromParent(): void;
+    remove(): void;
+}
+export declare class NestedSearchStatement implements ISearchNode {
+    owner: SearchStatementState;
+    statement: SearchStatementState | null;
+    as: string | null;
+    constructor(owner: SearchStatementState);
+    get type(): SearchStatementNodeType.NestedSearchStatement;
+    get id(): string;
+    get isValid(): boolean;
+    get columns(): ColumnRef[];
+    get mainPersistedEntity(): DefinitionEntityState | null;
+    get selections(): (ColumnRef | AllColumnsSelector)[];
+    get selectedColumns(): ColumnRef[];
+    get primaryKeys(): ColumnRef[];
+    get primaryKey(): ColumnRef | null;
+    toQuery(): string;
+}
+export declare enum DataSourceType {
+    Table = "table",
+    Query = "query",
+    Aggregation = "aggregation"
+}
+export declare class DataSource implements IDataSource, ISearchNode {
+    owner: SearchStatementState;
+    entity: DefinitionEntityState | null;
+    query: NestedSearchStatement | null;
+    aggregation: AggregationStatement | null;
+    sourceType: DataSourceType | null;
+    constructor(owner: SearchStatementState);
+    get id(): string;
+    get type(): SearchStatementNodeType.DataSource;
+    get isValid(): boolean;
+    get source(): DefinitionEntityState | NestedSearchStatement | AggregationStatement | null;
+    set as(as: string);
+    get as(): string;
+    get columns(): ColumnRef[];
+    get selections(): (ColumnRef | AllColumnsSelector)[];
+    get mainPersistedEntity(): DefinitionEntityState | null;
+    get selectedColumns(): ColumnRef[];
+    get primaryKeys(): ColumnRef[];
+    get primaryKey(): ColumnRef | null;
+}
+export declare class ColumnRef implements ISearchNode {
+    owner: SearchStatementState;
+    source: ColumnRef | PropertyState | LiteralValue | null;
+    parent: DataSource | null;
+    _id: string;
+    _as: string | null;
+    constructor(owner: SearchStatementState);
+    set as(as: string);
+    get as(): string;
+    get property(): PropertyState | null;
+    get literalValue(): LiteralValue | null;
+    get type(): SearchStatementNodeType.ColumnRef;
+    get id(): string;
+    get isValid(): boolean;
+}
+export declare class AllColumnsSelector implements ISearchNode {
+    owner: SearchStatementState;
+    parent: DataSource | null;
+    constructor(owner: SearchStatementState);
+    get type(): SearchStatementNodeType.AllColumnsSelector;
+    get id(): string;
+    get isValid(): boolean;
+    get columns(): ColumnRef[];
+    get selectedColumns(): ColumnRef[];
+}
+export declare enum SortStatementDirection {
+    Ascending = "asc",
+    Descending = "desc"
+}
+export declare class SortStatement implements ISearchNode {
+    owner: SearchStatementState;
+    column: ColumnRef | null;
+    direction: SortStatementDirection;
+    index: number;
+    constructor(owner: SearchStatementState);
+    get type(): SearchStatementNodeType.SortStatement;
+    get isValid(): boolean;
+}
+export declare class SearchStatementState implements ISearchNode {
+    id: string;
+    selections: (ColumnRef | AllColumnsSelector)[];
+    from: DataSource | null;
+    aggregations: AggregationStatement[];
+    where: WhereStatement | null;
+    offset: InputMapState | LiteralValue | null;
+    limit: InputMapState | LiteralValue | null;
+    asList: boolean;
+    sorting: SortStatement[];
+    dataSources: DataSource[];
+    constructor(id: string);
+    get isUntouchedEntity(): boolean;
+    get usedDataSources(): DataSource[];
+    get type(): SearchStatementNodeType.SearchStatement;
+    get mainPersistedEntity(): DefinitionEntityState | null;
+    get mainDatabaseEntity(): DefinitionEntityState | null;
+    get validSortings(): SortStatement[];
+    get selectedColumns(): ColumnRef[];
+    get validSelections(): (ColumnRef | AllColumnsSelector)[];
+    get validSelectedColumns(): ColumnRef[];
+    get columns(): ColumnRef[];
+    get isValid(): boolean;
+    get primaryKeys(): ColumnRef[];
+    get primaryKey(): ColumnRef | null;
+    get duplicateColumnNames(): string[];
+    get isOnlyAllFromSelected(): boolean;
+    addDataSource(dataSource: DataSource): DataSource;
+    getDataSource(id: string): DataSource | null;
+    editDataSource(dataSource: DataSource): DataSource | null;
+    toQuery(): string;
+    calculateAst(): {
+        ast: SQLAST | null;
+        query: string | null;
+    };
+    addAggregation(aggregation: AggregationStatement): void;
+    removeAggregation(aggregation: AggregationStatement): void;
+    editAggregation(aggregation: AggregationStatement): void;
+    addSort(sort: SortStatement): void;
+    removeSort(sort: SortStatement): void;
+    editSort(sort: SortStatement): void;
+    addSelection(selection: ColumnRef | AllColumnsSelector): void;
+    removeSelection(selection: ColumnRef | AllColumnsSelector): void;
+    editSelection(selection: ColumnRef | AllColumnsSelector): void;
+    setFrom(from: DataSource): void;
+    setWhere(where: WhereStatement): void;
+    setLimit(limit: LiteralValue | InputMapState): void;
+    setOffset(offset: LiteralValue | InputMapState): void;
+    setAsList(asList: boolean): void;
+}
+export {};

package/dist/tree/state/search/query/search-statement-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tree/state/search/search.d.ts

@@ -10,6 +10,7 @@ import { ValueDescriptorState } from '../value-descriptor';
 import { VersionedState } from '../version';
 import { ChangeSet, IChangeSet } from '../change-set';
 import { DefinitionEntityState } from '../definition-entity';
+import { SearchStatementState } from './query/search-statement-state';
 
 export declare enum SearchDependencyField {
     Parent = "parent"
@@ -36,6 +37,7 @@ export declare class SearchState extends VersionedState implements ISearch, Base
     parent: EntityWithLogicScopeState | ProjectState;
     errors: EntityError[];
     project: ProjectState;
+    state: SearchStatementState | null;
     detachedDependents: Record<EntityId, {
         entity: UserManagedEntityState;
         field: string;
@@ -69,8 +71,14 @@ export declare class SearchState extends VersionedState implements ISearch, Base
         modifiedData: ISearchGenerationTarget;
     };
     get resultsAsList(): boolean;
+    queryToState(): SearchStatementState;
+    stateToQuery(): string;
+    rehydrateQuery(): string;
+    onProjectInitialized(_project: ProjectState, changeSet?: ChangeSet | null): SearchState;
+    onPersistedEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
     onPersistedEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
     onPersistedEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
+    onRelationalDatabaseEntityUpdated(_updatedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
     onRelationalDatabaseEntityAdded(_newEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
     onRelationalDatabaseEntityRemoved(_removedEntity: DefinitionEntityState, changeSet?: ChangeSet | null): SearchState;
     validateGeneratedUpdate(data: Partial<ISearchGenerationTarget>): {

package/dist/tree/utils/index.d.ts

@@ -274,6 +274,7 @@ export declare function checkHasBaseEntity(entity: DefinitionEntityState | Built
 export declare function getPeristedEntities(project: ProjectState): DefinitionEntityState[];
 export declare function getDatabaseEntities(project: ProjectState): DefinitionEntityState[];
 export declare function resolvePrimaryKeyProperty(entity: DefinitionEntityState): PropertyState | null;
+export declare function resolvePersistedDefinitionEntityDatabaseEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
 export declare function getColumnProperties(entity: DefinitionEntityState): PropertyState[];
 export declare function getDatabaseEntity(entity: DefinitionEntityState): DefinitionEntityState | null;
 export declare function resolveClonedEntityProject(newParent: EntityState | null, self: EntityState): ProjectState;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elyx-code/project-logic-tree",
-	"version": "0.0.6278",
+	"version": "0.0.6280",
 	"author": "Sergio Herrero",
 	"license": "UNLICENSED",
 	"description": "An installable module which contains the type definitions and ephemeral state management for a projects' logic tree data structure",
@@ -29,6 +29,7 @@
 		"dayjs": "^1.11.13",
 		"pluralize": "^8.0.0",
 		"short-uuid": "^5.2.0",
+		"sql-parser-cst": "^0.33.1",
 		"underscore": "^1.13.7",
 		"zod": "^3.22.4",
 		"zod-validation-error": "^3.3.0"