@iamjulianacosta/mobx-data 1.1.0 → 1.4.0

package/src/inspector/types.ts

@@ -0,0 +1,161 @@
+export interface StoreSummary {
+  types: Array<{ modelName: string; count: number }>;
+  totalRecords: number;
+}
+
+export interface RecordSummary {
+  modelName: string;
+  id: string | null;
+  clientId: string;
+  currentState: string;
+  isNew: boolean;
+  isDirty: boolean;
+  isDeleted: boolean;
+  isError: boolean;
+  isLoading: boolean;
+  isSaving: boolean;
+  hasDirtyAttributes: boolean;
+  hasErrors: boolean;
+}
+
+export interface RecordDetail extends RecordSummary {
+  attributes: Record<string, unknown>;
+  originalAttributes: Record<string, unknown>;
+  changedAttributes: Record<string, [unknown, unknown]>;
+  relationships: Record<string, unknown>;
+  errors: Array<{ attribute: string; messages: string[] }>;
+}
+
+export interface SchemaInfo {
+  modelName: string;
+  isAbstract: boolean;
+  discriminator: { key: string } | null;
+  attributes: Array<{ name: string; type: string | null }>;
+  relationships: Array<{
+    name: string;
+    kind: 'belongsTo' | 'hasMany';
+    type: string;
+    async: boolean;
+    inverse: string | null;
+    polymorphic: boolean;
+  }>;
+}
+
+export interface InspectorChangeEvent {
+  type: 'added' | 'removed' | 'updated';
+  modelName: string;
+  id: string | null;
+  record?: RecordSummary;
+}
+
+export interface DevToolsMessage {
+  source: 'mobx-data-devtools';
+  direction: 'page-to-panel' | 'panel-to-page';
+  payload: DevToolsPayload;
+}
+
+export type DevToolsPayload =
+  | DevToolsInitPayload
+  | DevToolsSummaryPayload
+  | DevToolsRecordsPayload
+  | DevToolsRecordDetailPayload
+  | DevToolsSchemaPayload
+  | DevToolsSnapshotPayload
+  | DevToolsChangeEventPayload
+  | DevToolsQueryResultPayload
+  | DevToolsRequestSummaryPayload
+  | DevToolsRequestRecordsPayload
+  | DevToolsRequestRecordDetailPayload
+  | DevToolsRequestSchemaPayload
+  | DevToolsRequestSnapshotPayload
+  | DevToolsRequestQueryPayload;
+
+export interface DevToolsInitPayload {
+  type: 'init';
+  storeId: string;
+  storeCount: number;
+  version: string;
+}
+
+export interface DevToolsSummaryPayload {
+  type: 'summary';
+  storeId: string;
+  data: StoreSummary;
+}
+
+export interface DevToolsRecordsPayload {
+  type: 'records';
+  storeId: string;
+  modelName: string;
+  data: RecordSummary[];
+}
+
+export interface DevToolsRecordDetailPayload {
+  type: 'recordDetail';
+  storeId: string;
+  modelName: string;
+  id: string;
+  data: RecordDetail;
+}
+
+export interface DevToolsSchemaPayload {
+  type: 'schema';
+  storeId: string;
+  modelName: string;
+  data: SchemaInfo;
+}
+
+export interface DevToolsSnapshotPayload {
+  type: 'snapshot';
+  storeId: string;
+  data: unknown;
+}
+
+export interface DevToolsChangeEventPayload {
+  type: 'changeEvent';
+  storeId: string;
+  event: InspectorChangeEvent;
+}
+
+export interface DevToolsRequestSummaryPayload {
+  type: 'requestSummary';
+  storeId: string;
+}
+
+export interface DevToolsRequestRecordsPayload {
+  type: 'requestRecords';
+  storeId: string;
+  modelName: string;
+}
+
+export interface DevToolsRequestRecordDetailPayload {
+  type: 'requestRecordDetail';
+  storeId: string;
+  modelName: string;
+  id: string;
+}
+
+export interface DevToolsRequestSchemaPayload {
+  type: 'requestSchema';
+  storeId: string;
+  modelName: string;
+}
+
+export interface DevToolsRequestSnapshotPayload {
+  type: 'requestSnapshot';
+  storeId: string;
+}
+
+export interface DevToolsRequestQueryPayload {
+  type: 'requestQuery';
+  storeId: string;
+  queryText: string;
+}
+
+export interface DevToolsQueryResultPayload {
+  type: 'queryResult';
+  storeId: string;
+  queryText: string;
+  data: RecordSummary[];
+  error: string | null;
+}

package/src/mdql/MdqlMemoryExecutor.ts

@@ -0,0 +1,229 @@
+import type { Model } from '@mobx-data/model';
+import type {
+  MdqlCondition,
+  MdqlFilterNode,
+  MdqlQueryObject,
+  MdqlOrderByClause,
+} from './types.js';
+
+export class MdqlMemoryExecutor {
+  static executeMany<T extends Model = Model>(
+    items: T[],
+    query: MdqlQueryObject,
+  ): T[] {
+    let result = items.filter((record) =>
+      MdqlMemoryExecutor.matchesNode(record, query.filters),
+    );
+
+    if (query.orderBy.length > 0) {
+      result = MdqlMemoryExecutor.sortRecords(result, query.orderBy);
+    }
+
+    const offset = query.offset ?? 0;
+    if (offset > 0 || query.limit !== null) {
+      const end = query.limit !== null ? offset + query.limit : undefined;
+      result = result.slice(offset, end);
+    }
+
+    return result;
+  }
+
+  static executeOne<T extends Model = Model>(
+    items: T[],
+    query: MdqlQueryObject,
+  ): T | null {
+    const results = MdqlMemoryExecutor.executeMany(items, query);
+    return results[0] ?? null;
+  }
+
+  static count<T extends Model = Model>(
+    items: T[],
+    query: MdqlQueryObject,
+  ): number {
+    let count = 0;
+    for (const record of items) {
+      if (MdqlMemoryExecutor.matchesNode(record, query.filters)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  static exists<T extends Model = Model>(
+    items: T[],
+    query: MdqlQueryObject,
+  ): boolean {
+    return items.some((record) =>
+      MdqlMemoryExecutor.matchesNode(record, query.filters),
+    );
+  }
+
+  static compilePredicate<T extends Model = Model>(
+    query: MdqlQueryObject,
+  ): (record: T) => boolean {
+    return (record: T) => MdqlMemoryExecutor.matchesNode(record, query.filters);
+  }
+
+  private static matchesNode(record: Model, node: MdqlFilterNode): boolean {
+    if (node.kind === 'condition') {
+      return MdqlMemoryExecutor.evaluateCondition(record, node);
+    }
+
+    if (node.kind === 'and') {
+      return node.children.every((child) =>
+        MdqlMemoryExecutor.matchesNode(record, child),
+      );
+    }
+
+    if (node.kind === 'or') {
+      return node.children.some((child) =>
+        MdqlMemoryExecutor.matchesNode(record, child),
+      );
+    }
+
+    // not
+    return !node.children.some((child) =>
+      MdqlMemoryExecutor.matchesNode(record, child),
+    );
+  }
+
+  private static resolveFieldValues(record: Model, field: string): unknown[] {
+    const parts = field.split('.');
+    let currentValues: unknown[] = [record];
+    for (const part of parts) {
+      const nextValues: unknown[] = [];
+      for (const current of currentValues) {
+        if (current === null || current === undefined) continue;
+        if (Array.isArray(current)) {
+          for (const item of current) {
+            if (item === null || item === undefined) continue;
+            nextValues.push((item as Record<string, unknown>)[part]);
+          }
+        } else {
+          nextValues.push((current as Record<string, unknown>)[part]);
+        }
+      }
+      currentValues = nextValues;
+    }
+    return currentValues;
+  }
+
+  private static resolveFieldValue(record: Model, field: string): unknown {
+    const values = MdqlMemoryExecutor.resolveFieldValues(record, field);
+    return values.length === 1 ? values[0] : values.length === 0 ? undefined : values;
+  }
+
+  private static evaluateCondition(record: Model, condition: MdqlCondition): boolean {
+    const resolvedValues = MdqlMemoryExecutor.resolveFieldValues(record, condition.field);
+    if (resolvedValues.length > 1) {
+      return resolvedValues.some((fieldValue) =>
+        MdqlMemoryExecutor.evaluateSingleCondition(fieldValue, condition.operator, condition.value),
+      );
+    }
+    const fieldValue = resolvedValues[0];
+    return MdqlMemoryExecutor.evaluateSingleCondition(fieldValue, condition.operator, condition.value);
+  }
+
+  private static evaluateSingleCondition(fieldValue: unknown, operator: string, value: unknown): boolean {
+    switch (operator) {
+      case 'equals':
+        return fieldValue === value;
+
+      case 'notEquals':
+        return fieldValue !== value;
+
+      case 'in':
+        return Array.isArray(value) && value.includes(fieldValue);
+
+      case 'notIn':
+        return Array.isArray(value) && !value.includes(fieldValue);
+
+      case 'isNull':
+        return fieldValue === null || fieldValue === undefined;
+
+      case 'isNotNull':
+        return fieldValue !== null && fieldValue !== undefined;
+
+      case 'contains':
+        return typeof fieldValue === 'string'
+          && typeof value === 'string'
+          && fieldValue.toLowerCase().includes(value.toLowerCase());
+
+      case 'startsWith':
+        return typeof fieldValue === 'string'
+          && typeof value === 'string'
+          && fieldValue.toLowerCase().startsWith(value.toLowerCase());
+
+      case 'endsWith':
+        return typeof fieldValue === 'string'
+          && typeof value === 'string'
+          && fieldValue.toLowerCase().endsWith(value.toLowerCase());
+
+      case 'greaterThan':
+        return MdqlMemoryExecutor.compareValues(fieldValue, value) > 0;
+
+      case 'greaterThanOrEquals':
+        return MdqlMemoryExecutor.compareValues(fieldValue, value) >= 0;
+
+      case 'lessThan':
+        return MdqlMemoryExecutor.compareValues(fieldValue, value) < 0;
+
+      case 'lessThanOrEquals':
+        return MdqlMemoryExecutor.compareValues(fieldValue, value) <= 0;
+
+      case 'between': {
+        if (!Array.isArray(value) || value.length !== 2) return false;
+        const lower = MdqlMemoryExecutor.compareValues(fieldValue, value[0]);
+        const upper = MdqlMemoryExecutor.compareValues(fieldValue, value[1]);
+        return lower >= 0 && upper <= 0;
+      }
+
+      default:
+        return false;
+    }
+  }
+
+  private static compareValues(a: unknown, b: unknown): number {
+    if (a === null || a === undefined) return -1;
+    if (b === null || b === undefined) return 1;
+
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() - b.getTime();
+    }
+
+    if (typeof a === 'number' && typeof b === 'number') {
+      return a - b;
+    }
+
+    if (typeof a === 'string' && typeof b === 'string') {
+      return a.localeCompare(b);
+    }
+
+    return String(a).localeCompare(String(b));
+  }
+
+  private static sortRecords<T extends Model>(
+    records: T[],
+    orderBy: MdqlOrderByClause[],
+  ): T[] {
+    return [...records].sort((a, b) => {
+      for (const clause of orderBy) {
+        const valueA = MdqlMemoryExecutor.resolveFieldValue(a, clause.field);
+        const valueB = MdqlMemoryExecutor.resolveFieldValue(b, clause.field);
+
+        if (valueA === valueB) continue;
+
+        // Nulls always sort last regardless of direction
+        if (valueA === null || valueA === undefined) return 1;
+        if (valueB === null || valueB === undefined) return -1;
+
+        const comparison = MdqlMemoryExecutor.compareValues(valueA, valueB);
+        if (comparison !== 0) {
+          return clause.direction === 'desc' ? -comparison : comparison;
+        }
+      }
+
+      return 0;
+    });
+  }
+}

package/src/mdql/MdqlQueryBuilder.ts

@@ -0,0 +1,170 @@
+import type { Model } from '@mobx-data/model';
+import type { Store } from '@mobx-data/store';
+import type { RecordArray } from '../store/RecordArray.js';
+import type {
+  MdqlCondition,
+  MdqlLogicalGroup,
+  MdqlOperator,
+  MdqlOperatorFor,
+  MdqlValueFor,
+  MdqlQueryObject,
+  MdqlSortDirection,
+  ModelFields,
+} from './types.js';
+import { MdqlValidator } from './MdqlValidator.js';
+import { MdqlMemoryExecutor } from './MdqlMemoryExecutor.js';
+
+type Fields<T extends Model> = ModelFields<T>;
+type FieldKey<T extends Model> = Extract<keyof Fields<T>, string>;
+
+export class MdqlQueryBuilder<T extends Model = Model> {
+  private readonly store: Store;
+  private readonly queryModelName: string;
+  private readonly rootGroup: MdqlLogicalGroup;
+  private readonly orderByClauses: Array<{ field: string; direction: MdqlSortDirection }>;
+  private limitValue: number | null;
+  private offsetValue: number | null;
+  private readonly includesList: string[];
+
+  constructor(store: Store, modelName: string) {
+    this.store = store;
+    this.queryModelName = modelName;
+    this.rootGroup = { kind: 'and', children: [] };
+    this.orderByClauses = [];
+    this.limitValue = null;
+    this.offsetValue = null;
+    this.includesList = [];
+  }
+
+  where<
+    TKey extends FieldKey<T>,
+    TOp extends MdqlOperatorFor<Fields<T>[TKey]>,
+  >(
+    field: TKey,
+    operator: TOp,
+    value?: MdqlValueFor<Fields<T>[TKey], TOp>,
+  ): this;
+  where(field: string, operator: MdqlOperator, value?: unknown): this;
+  where(field: string, operator: MdqlOperator, value?: unknown): this {
+    const condition: MdqlCondition = {
+      kind: 'condition',
+      field,
+      operator,
+      value,
+    };
+    this.rootGroup.children.push(condition);
+    return this;
+  }
+
+  whereEquals<TKey extends FieldKey<T>>(
+    field: TKey,
+    value: Fields<T>[TKey],
+  ): this;
+  whereEquals(field: string, value: unknown): this;
+  whereEquals(field: string, value: unknown): this {
+    return this.where(field, 'equals', value);
+  }
+
+  whereContains<TKey extends FieldKey<T>>(
+    field: TKey,
+    value: string,
+  ): this;
+  whereContains(field: string, value: string): this;
+  whereContains(field: string, value: string): this {
+    return this.where(field, 'contains', value);
+  }
+
+  and(callback: (builder: MdqlQueryBuilder<T>) => void): this {
+    const sub = new MdqlQueryBuilder<T>(this.store, this.queryModelName);
+    callback(sub);
+    const group: MdqlLogicalGroup = { kind: 'and', children: [...sub.rootGroup.children] };
+    this.rootGroup.children.push(group);
+    return this;
+  }
+
+  or(callback: (builder: MdqlQueryBuilder<T>) => void): this {
+    const sub = new MdqlQueryBuilder<T>(this.store, this.queryModelName);
+    callback(sub);
+    const group: MdqlLogicalGroup = { kind: 'or', children: [...sub.rootGroup.children] };
+    this.rootGroup.children.push(group);
+    return this;
+  }
+
+  not(callback: (builder: MdqlQueryBuilder<T>) => void): this {
+    const sub = new MdqlQueryBuilder<T>(this.store, this.queryModelName);
+    callback(sub);
+    const group: MdqlLogicalGroup = { kind: 'not', children: [...sub.rootGroup.children] };
+    this.rootGroup.children.push(group);
+    return this;
+  }
+
+  orderBy(field: FieldKey<T>, direction?: MdqlSortDirection): this;
+  orderBy(field: string, direction?: MdqlSortDirection): this;
+  orderBy(field: string, direction: MdqlSortDirection = 'asc'): this {
+    this.orderByClauses.push({ field, direction });
+    return this;
+  }
+
+  limit(value: number): this {
+    this.limitValue = value;
+    return this;
+  }
+
+  offset(value: number): this {
+    this.offsetValue = value;
+    return this;
+  }
+
+  include(relation: string): this {
+    if (!this.includesList.includes(relation)) {
+      this.includesList.push(relation);
+    }
+    return this;
+  }
+
+  toQueryObject(): MdqlQueryObject {
+    return {
+      modelName: this.queryModelName,
+      filters: { kind: 'and', children: [...this.rootGroup.children] },
+      orderBy: [...this.orderByClauses],
+      limit: this.limitValue,
+      offset: this.offsetValue,
+      includes: [...this.includesList],
+    };
+  }
+
+  async toArray(): Promise<T[]> {
+    const query = this.toQueryObject();
+    MdqlValidator.validate(query, this.store.schema);
+    const items = this.store.peekAll<T>(this.queryModelName).toArray();
+    return MdqlMemoryExecutor.executeMany<T>(items, query);
+  }
+
+  async first(): Promise<T | null> {
+    const query = this.toQueryObject();
+    MdqlValidator.validate(query, this.store.schema);
+    const items = this.store.peekAll<T>(this.queryModelName).toArray();
+    return MdqlMemoryExecutor.executeOne<T>(items, query);
+  }
+
+  async count(): Promise<number> {
+    const query = this.toQueryObject();
+    MdqlValidator.validate(query, this.store.schema);
+    const items = this.store.peekAll<T>(this.queryModelName).toArray();
+    return MdqlMemoryExecutor.count<T>(items, query);
+  }
+
+  async exists(): Promise<boolean> {
+    const query = this.toQueryObject();
+    MdqlValidator.validate(query, this.store.schema);
+    const items = this.store.peekAll<T>(this.queryModelName).toArray();
+    return MdqlMemoryExecutor.exists<T>(items, query);
+  }
+
+  toLiveArray(): RecordArray<T> {
+    const query = this.toQueryObject();
+    MdqlValidator.validate(query, this.store.schema);
+    const predicate = MdqlMemoryExecutor.compilePredicate<T>(query);
+    return this.store.liveQuery<T>(this.queryModelName, predicate);
+  }
+}