@iamjulianacosta/mobx-data 1.1.0 → 1.4.0

package/src/inspector/QueryParser.ts

@@ -0,0 +1,343 @@
+import type {
+  MdqlQueryObject,
+  MdqlFilterNode,
+  MdqlCondition,
+  MdqlLogicalGroup,
+  MdqlOperator,
+  MdqlOrderByClause,
+  MdqlSortDirection,
+} from '@mobx-data/mdql';
+
+interface Token {
+  type: 'keyword' | 'operator' | 'string' | 'number' | 'identifier' | 'null' | 'bracket';
+  value: string;
+  raw: unknown;
+}
+
+const KEYWORD_SET = new Set([
+  'where', 'and', 'or', 'not', 'order', 'by', 'sort',
+  'limit', 'offset', 'is', 'null', 'in', 'between',
+  'asc', 'desc', 'contains', 'startswith', 'endswith',
+]);
+
+const OPERATOR_MAP: Record<string, MdqlOperator> = {
+  '=': 'equals',
+  '==': 'equals',
+  '!=': 'notEquals',
+  '<>': 'notEquals',
+  '>': 'greaterThan',
+  '>=': 'greaterThanOrEquals',
+  '<': 'lessThan',
+  '<=': 'lessThanOrEquals',
+  '~': 'contains',
+  '^=': 'startsWith',
+  '$=': 'endsWith',
+  'contains': 'contains',
+  'startswith': 'startsWith',
+  'endswith': 'endsWith',
+};
+
+const OPERATOR_CHARS = new Set(['=', '!', '<', '>', '~', '^', '$']);
+
+export class QueryParser {
+  static parse(input: string): MdqlQueryObject {
+    const parser = new QueryParser(input);
+    return parser.parseQuery();
+  }
+
+  private tokens: Token[];
+  private position: number;
+
+  private constructor(input: string) {
+    this.tokens = QueryParser.tokenize(input);
+    this.position = 0;
+  }
+
+  private static tokenize(input: string): Token[] {
+    const tokens: Token[] = [];
+    let index = 0;
+
+    while (index < input.length) {
+      if (input[index] === ' ' || input[index] === '\t') {
+        index++;
+        continue;
+      }
+
+      if (input[index] === '[' || input[index] === ']' || input[index] === ',') {
+        tokens.push({ type: 'bracket', value: input[index]!, raw: input[index] });
+        index++;
+        continue;
+      }
+
+      if (input[index] === '"' || input[index] === "'") {
+        const quote = input[index]!;
+        let value = '';
+        index++;
+        while (index < input.length && input[index] !== quote) {
+          if (input[index] === '\\' && index + 1 < input.length) {
+            index++;
+          }
+          value += input[index];
+          index++;
+        }
+        index++;
+        tokens.push({ type: 'string', value, raw: value });
+        continue;
+      }
+
+      if (OPERATOR_CHARS.has(input[index]!)) {
+        let operator = '';
+        while (index < input.length && OPERATOR_CHARS.has(input[index]!)) {
+          operator += input[index];
+          index++;
+        }
+        tokens.push({ type: 'operator', value: operator, raw: operator });
+        continue;
+      }
+
+      let word = '';
+      while (index < input.length && input[index] !== ' ' && input[index] !== '\t'
+        && !OPERATOR_CHARS.has(input[index]!) && input[index] !== '[' && input[index] !== ']' && input[index] !== ',') {
+        word += input[index];
+        index++;
+      }
+
+      if (word === '') {
+        index++;
+        continue;
+      }
+
+      const lower = word.toLowerCase();
+
+      if (lower === 'null') {
+        tokens.push({ type: 'null', value: 'null', raw: null });
+      } else if (KEYWORD_SET.has(lower)) {
+        tokens.push({ type: 'keyword', value: lower, raw: word });
+      } else {
+        const numberValue = Number(word);
+        if (!Number.isNaN(numberValue) && word !== '') {
+          tokens.push({ type: 'number', value: word, raw: numberValue });
+        } else {
+          tokens.push({ type: 'identifier', value: word, raw: word });
+        }
+      }
+    }
+
+    return tokens;
+  }
+
+  private peek(): Token | null {
+    return this.tokens[this.position] ?? null;
+  }
+
+  private advance(): Token | null {
+    const token = this.tokens[this.position] ?? null;
+    this.position++;
+    return token;
+  }
+
+  private expect(type: string, value?: string): Token {
+    const token = this.advance();
+    if (!token || token.type !== type || (value !== undefined && token.value !== value)) {
+      const got = token ? `${token.type}:${token.value}` : 'end of input';
+      throw new Error(`Expected ${type}${value ? `:${value}` : ''}, got ${got}`);
+    }
+    return token;
+  }
+
+  private expectNullToken(): void {
+    const token = this.advance();
+    if (!token || (token.type !== 'null' && token.value !== 'null')) {
+      const got = token ? `${token.type}:${token.value}` : 'end of input';
+      throw new Error(`Expected null, got ${got}`);
+    }
+  }
+
+  private matchKeyword(keyword: string): boolean {
+    const token = this.peek();
+    if (token?.type === 'keyword' && token.value === keyword) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+
+  private parseQuery(): MdqlQueryObject {
+    const modelToken = this.advance();
+    if (!modelToken) throw new Error('Expected model name');
+    const modelName = modelToken.value;
+
+    let filters: MdqlLogicalGroup = { kind: 'and', children: [] };
+    const orderBy: MdqlOrderByClause[] = [];
+    let limit: number | null = null;
+    let offset: number | null = null;
+
+    if (this.matchKeyword('where')) {
+      filters = this.parseFilterExpression();
+    }
+
+    if (this.matchKeyword('order')) {
+      this.expect('keyword', 'by');
+      this.parseOrderBy(orderBy);
+    } else if (this.matchKeyword('sort')) {
+      this.parseOrderBy(orderBy);
+    }
+
+    if (this.matchKeyword('limit')) {
+      const token = this.expect('number');
+      limit = token.raw as number;
+    }
+
+    if (this.matchKeyword('offset')) {
+      const token = this.expect('number');
+      offset = token.raw as number;
+    }
+
+    return { modelName, filters, orderBy, limit, offset, includes: [] };
+  }
+
+  private parseFilterExpression(): MdqlLogicalGroup {
+    const first = this.parseCondition();
+    const children: MdqlFilterNode[] = [first];
+    let groupKind: 'and' | 'or' = 'and';
+
+    while (this.peek()) {
+      const token = this.peek()!;
+      if (token.type === 'keyword' && token.value === 'and') {
+        this.advance();
+        groupKind = 'and';
+        children.push(this.parseCondition());
+      } else if (token.type === 'keyword' && token.value === 'or') {
+        this.advance();
+        groupKind = 'or';
+        children.push(this.parseCondition());
+      } else {
+        break;
+      }
+    }
+
+    if (children.length === 1 && first.kind !== 'condition') {
+      return first as MdqlLogicalGroup;
+    }
+
+    return { kind: groupKind, children };
+  }
+
+  private parseCondition(): MdqlFilterNode {
+    if (this.matchKeyword('not')) {
+      const child = this.parseCondition();
+      return { kind: 'not', children: [child] };
+    }
+
+    const fieldToken = this.advance();
+    if (!fieldToken) throw new Error('Expected field name');
+    const field = fieldToken.value;
+
+    if (this.peek()?.type === 'keyword' && this.peek()?.value === 'is') {
+      this.advance();
+      if (this.matchKeyword('not')) {
+        this.expectNullToken();
+        return { kind: 'condition', field, operator: 'isNotNull', value: undefined };
+      }
+      this.expectNullToken();
+      return { kind: 'condition', field, operator: 'isNull', value: undefined };
+    }
+
+    if (this.peek()?.type === 'keyword' && this.peek()?.value === 'in') {
+      this.advance();
+      const values = this.parseArray();
+      return { kind: 'condition', field, operator: 'in', value: values };
+    }
+
+    if (this.peek()?.type === 'keyword' && this.peek()?.value === 'between') {
+      this.advance();
+      const low = this.parseValue();
+      const high = this.parseValue();
+      return { kind: 'condition', field, operator: 'between', value: [low, high] };
+    }
+
+    const operatorToken = this.advance();
+    if (!operatorToken) throw new Error(`Expected operator after field "${field}"`);
+
+    let operator: MdqlOperator;
+    if (operatorToken.type === 'operator') {
+      operator = OPERATOR_MAP[operatorToken.value] as MdqlOperator;
+      if (!operator) throw new Error(`Unknown operator: ${operatorToken.value}`);
+    } else if (operatorToken.type === 'keyword' && OPERATOR_MAP[operatorToken.value]) {
+      operator = OPERATOR_MAP[operatorToken.value] as MdqlOperator;
+    } else {
+      throw new Error(`Expected operator, got ${operatorToken.type}:${operatorToken.value}`);
+    }
+
+    const value = this.parseValue();
+
+    return { kind: 'condition', field, operator, value } as MdqlCondition;
+  }
+
+  private parseOrderBy(orderBy: MdqlOrderByClause[]): void {
+    const fieldToken = this.advance();
+    if (!fieldToken) throw new Error('Expected field name after order by / sort');
+    orderBy.push({
+      field: fieldToken.value,
+      direction: this.parseDirection(),
+    });
+
+    while (this.peek()?.type === 'bracket' && this.peek()?.value === ',') {
+      this.advance();
+      const nextField = this.advance();
+      if (!nextField) break;
+      orderBy.push({
+        field: nextField.value,
+        direction: this.parseDirection(),
+      });
+    }
+  }
+
+  private parseDirection(): MdqlSortDirection {
+    const token = this.peek();
+    if (token?.type === 'keyword' && (token.value === 'asc' || token.value === 'desc')) {
+      this.advance();
+      return token.value as MdqlSortDirection;
+    }
+    return 'asc';
+  }
+
+  private parseValue(): unknown {
+    const token = this.advance();
+    if (!token) throw new Error('Expected value');
+
+    if (token.type === 'string') return token.raw;
+    if (token.type === 'number') return token.raw;
+    if (token.type === 'null') return null;
+    if (token.type === 'keyword' && token.value === 'null') return null;
+    if (token.type === 'identifier') return token.value;
+
+    throw new Error(`Unexpected value token: ${token.type}:${token.value}`);
+  }
+
+  private parseArray(): unknown[] {
+    const values: unknown[] = [];
+    if (this.peek()?.type === 'bracket' && this.peek()?.value === '[') {
+      this.advance();
+      while (this.peek() && !(this.peek()?.type === 'bracket' && this.peek()?.value === ']')) {
+        if (this.peek()?.type === 'bracket' && this.peek()?.value === ',') {
+          this.advance();
+          continue;
+        }
+        values.push(this.parseValue());
+      }
+      if (this.peek()?.type === 'bracket' && this.peek()?.value === ']') {
+        this.advance();
+      }
+    } else {
+      while (this.peek() && this.peek()?.type !== 'keyword') {
+        if (this.peek()?.type === 'bracket' && this.peek()?.value === ',') {
+          this.advance();
+          continue;
+        }
+        values.push(this.parseValue());
+      }
+    }
+    return values;
+  }
+}

package/src/inspector/StoreInspector.ts

@@ -0,0 +1,162 @@
+import { reaction } from 'mobx';
+import type { Model } from '@mobx-data/model';
+import type { Store } from '@mobx-data/store';
+import type { MdqlQueryObject } from '@mobx-data/mdql';
+import { MdqlMemoryExecutor } from '../mdql/MdqlMemoryExecutor.js';
+import { QueryParser } from './QueryParser.js';
+import type {
+  StoreSummary,
+  RecordSummary,
+  RecordDetail,
+  SchemaInfo,
+  InspectorChangeEvent,
+} from './types.js';
+import { summarizeRecord, detailRecord, extractSchemaInfo } from './serialization.js';
+
+export class StoreInspector {
+  private readonly store: Store;
+
+  constructor(store: Store) {
+    this.store = store;
+  }
+
+  summary(): StoreSummary {
+    const types: StoreSummary['types'] = [];
+    let totalRecords = 0;
+    for (const modelName of this.store.schema.registeredNames()) {
+      const count = this.store.peekAll(modelName).length;
+      if (count > 0) {
+        types.push({ modelName, count });
+      }
+      totalRecords += count;
+    }
+    types.sort((a, b) => a.modelName.localeCompare(b.modelName));
+    return { types, totalRecords };
+  }
+
+  records(modelName: string): RecordSummary[] {
+    return this.store.peekAll(modelName).toArray().map(summarizeRecord);
+  }
+
+  record(modelName: string, id: string): RecordDetail | null {
+    const found = this.store.identityMap.get(modelName, id);
+    if (!found) {
+      return null;
+    }
+    return detailRecord(found);
+  }
+
+  dirty(): RecordSummary[] {
+    return this.allRecordsWhere((r) => r.isDirty);
+  }
+
+  newRecords(): RecordSummary[] {
+    return this.allRecordsWhere((r) => r.isNew);
+  }
+
+  errored(): RecordSummary[] {
+    return this.allRecordsWhere((r) => r.isError || !r.isValid);
+  }
+
+  saving(): RecordSummary[] {
+    return this.allRecordsWhere((r) => r.isSaving);
+  }
+
+  schema(modelName: string): SchemaInfo {
+    return extractSchemaInfo(this.store, modelName);
+  }
+
+  types(): string[] {
+    return this.store.schema.registeredNames().sort();
+  }
+
+  query(text: string): Model[] {
+    const queryObject = QueryParser.parse(text);
+    const items = this.store.peekAll(queryObject.modelName).toArray();
+    return MdqlMemoryExecutor.executeMany(items, queryObject);
+  }
+
+  queryWithMeta(text: string): { modelName: string; results: Model[] } {
+    const queryObject = QueryParser.parse(text);
+    const items = this.store.peekAll(queryObject.modelName).toArray();
+    return {
+      modelName: queryObject.modelName,
+      results: MdqlMemoryExecutor.executeMany(items, queryObject),
+    };
+  }
+
+  liveModels(modelName: string): Model[] {
+    return this.store.peekAll(modelName).toArray();
+  }
+
+  liveModel(modelName: string, id: string): Model | null {
+    return this.store.peekRecord(modelName, id);
+  }
+
+  snapshot(): { records: Record<string, unknown[]> } {
+    return this.store.serialize();
+  }
+
+  observe(callback: (event: InspectorChangeEvent) => void): () => void {
+    let previousState = this.captureState();
+
+    return reaction(
+      () => this.captureState(),
+      (currentState) => {
+        this.diffAndEmit(previousState, currentState, callback);
+        previousState = currentState;
+      },
+      { delay: 100 },
+    );
+  }
+
+  private allRecordsWhere(predicate: (record: Model) => boolean): RecordSummary[] {
+    const results: RecordSummary[] = [];
+    for (const modelName of this.store.schema.registeredNames()) {
+      for (const record of this.store.peekAll(modelName).toArray()) {
+        if (predicate(record)) {
+          results.push(summarizeRecord(record));
+        }
+      }
+    }
+    return results;
+  }
+
+  private captureState(): Map<string, Map<string, string>> {
+    const state = new Map<string, Map<string, string>>();
+    for (const [modelName, bucket] of this.store.identityMap._buckets) {
+      const records = new Map<string, string>();
+      for (const [id, record] of bucket) {
+        records.set(id, record.currentState);
+      }
+      state.set(modelName, records);
+    }
+    return state;
+  }
+
+  private diffAndEmit(
+    previous: Map<string, Map<string, string>>,
+    current: Map<string, Map<string, string>>,
+    callback: (event: InspectorChangeEvent) => void,
+  ): void {
+    for (const [modelName, currentBucket] of current) {
+      const previousBucket = previous.get(modelName);
+      for (const [id, currentStateValue] of currentBucket) {
+        if (!previousBucket?.has(id)) {
+          callback({ type: 'added', modelName, id });
+        } else if (previousBucket.get(id) !== currentStateValue) {
+          callback({ type: 'updated', modelName, id });
+        }
+      }
+    }
+
+    for (const [modelName, previousBucket] of previous) {
+      const currentBucket = current.get(modelName);
+      for (const [id] of previousBucket) {
+        if (!currentBucket?.has(id)) {
+          callback({ type: 'removed', modelName, id });
+        }
+      }
+    }
+  }
+}

package/src/inspector/index.ts

@@ -0,0 +1,20 @@
+export { StoreInspector } from './StoreInspector.js';
+export { ConsoleInspector } from './ConsoleInspector.js';
+export type { ResultSet, RecordResult } from './ConsoleInspector.js';
+export { QueryParser } from './QueryParser.js';
+export { DevToolsBridge } from './DevToolsBridge.js';
+export type { DevToolsHook } from './DevToolsBridge.js';
+export {
+  enableConsoleInspector,
+  enableDevTools,
+  enableInspector,
+} from './integration.js';
+export type {
+  StoreSummary,
+  RecordSummary,
+  RecordDetail,
+  SchemaInfo,
+  InspectorChangeEvent,
+  DevToolsMessage,
+  DevToolsPayload,
+} from './types.js';

package/src/inspector/integration.ts

@@ -0,0 +1,56 @@
+import type { Store } from '@mobx-data/store';
+import { ConsoleInspector } from './ConsoleInspector.js';
+import { DevToolsBridge } from './DevToolsBridge.js';
+
+let bridge: DevToolsBridge | null = null;
+let storeCounter = 0;
+
+declare global {
+  interface Window {
+    $mobxData?: ConsoleInspector;
+    $m?: (input: string) => unknown;
+  }
+}
+
+export function enableConsoleInspector(
+  store: Store,
+  name: string = 'default',
+): ConsoleInspector {
+  const inspector = new ConsoleInspector(store, name);
+  if (typeof window !== 'undefined') {
+    window.$mobxData = inspector;
+    window.$m = (input: string) => inspector.command(input);
+  }
+  return inspector;
+}
+
+export function enableDevTools(
+  store: Store,
+  storeId?: string,
+): () => void {
+  if (typeof window === 'undefined') {
+    return () => {};
+  }
+
+  if (!bridge) {
+    bridge = new DevToolsBridge();
+    bridge.install();
+  }
+
+  storeCounter += 1;
+  const resolvedId = storeId ?? `store-${storeCounter}`;
+  bridge.registerStore(resolvedId, store);
+
+  return () => {
+    bridge?.unregisterStore(resolvedId);
+  };
+}
+
+export function enableInspector(
+  store: Store,
+  name: string = 'default',
+): { consoleInspector: ConsoleInspector; cleanup: () => void } {
+  const consoleInspector = enableConsoleInspector(store, name);
+  const cleanup = enableDevTools(store, name);
+  return { consoleInspector, cleanup };
+}

package/src/inspector/serialization.ts

@@ -0,0 +1,100 @@
+import type { Model, RelationshipRef } from '@mobx-data/model';
+import type { Store } from '@mobx-data/store';
+import type { RecordSummary, RecordDetail, SchemaInfo } from './types.js';
+
+interface ModelInternals {
+  _data: Record<string, unknown>;
+  _originalData: Record<string, unknown>;
+  _relationships: Map<string, RelationshipRef>;
+  _clientId: string;
+}
+
+function internals(record: Model): ModelInternals {
+  return record as unknown as ModelInternals;
+}
+
+export function summarizeRecord(record: Model): RecordSummary {
+  return {
+    modelName: record.modelName,
+    id: record.id,
+    clientId: internals(record)._clientId,
+    currentState: record.currentState,
+    isNew: record.isNew,
+    isDirty: record.isDirty,
+    isDeleted: record.isDeleted,
+    isError: record.isError,
+    isLoading: record.isLoading,
+    isSaving: record.isSaving,
+    hasDirtyAttributes: record.hasDirtyAttributes,
+    hasErrors: !record.isValid,
+  };
+}
+
+export function detailRecord(record: Model): RecordDetail {
+  const internal = internals(record);
+  const relationships: Record<string, unknown> = {};
+  if (internal._relationships) {
+    for (const [name, reference] of internal._relationships) {
+      relationships[name] = reference;
+    }
+  }
+
+  const errors: Array<{ attribute: string; messages: string[] }> = [];
+  for (const [attribute, errorMessages] of record.errors) {
+    errors.push({
+      attribute,
+      messages: errorMessages.map((e) => e.message),
+    });
+  }
+
+  const attributes = Object.create(null) as Record<string, unknown>;
+  for (const key of Object.keys(internal._data)) {
+    if (key === '__proto__' || key === 'constructor') continue;
+    attributes[key] = internal._data[key];
+  }
+  const originalAttributes = Object.create(null) as Record<string, unknown>;
+  for (const key of Object.keys(internal._originalData)) {
+    if (key === '__proto__' || key === 'constructor') continue;
+    originalAttributes[key] = internal._originalData[key];
+  }
+
+  return {
+    ...summarizeRecord(record),
+    attributes,
+    originalAttributes,
+    changedAttributes: record.changedAttributes(),
+    relationships,
+    errors,
+  };
+}
+
+export function extractSchemaInfo(store: Store, modelName: string): SchemaInfo {
+  const attributeDefinitions = store.schema.attributesDefinitionFor(modelName);
+  const relationshipDefinitions = store.schema.relationshipsDefinitionFor(modelName);
+  const discriminator = store.schema.discriminatorFor(modelName);
+
+  const attributes: SchemaInfo['attributes'] = [];
+  for (const [name, definition] of attributeDefinitions) {
+    attributes.push({ name, type: definition.type });
+  }
+
+  const relationships: SchemaInfo['relationships'] = [];
+  for (const [name, definition] of relationshipDefinitions) {
+    relationships.push({
+      name,
+      kind: definition.kind,
+      type: definition.type,
+      async: definition.options.async ?? false,
+      inverse: definition.options.inverse ?? null,
+      polymorphic: definition.options.polymorphic ?? false,
+    });
+  }
+
+  return {
+    modelName,
+    isAbstract: store.schema.isAbstract(modelName),
+    discriminator: discriminator ? { key: discriminator.key } : null,
+    attributes,
+    relationships,
+  };
+}