메모리 비용 관점에서의 Proxy 객체와 공유 프로토타입 비교

function createQueryable<T>(obj: Record<string, T>) {
  return new Proxy(obj, {
    get(target: Record<string, T>, prop: string | symbol, receiver: unknown) {
      if (prop === WHERE) {
        return (predicate: (value: T, key: string) => boolean) => {
          const filtered = Object.entries(target)
            .filter(([key, value]) => predicate(value, key))
            .reduce((acc, [key, value]) => {
              acc[key] = value;
              return acc;
            }, {} as Record<string, T>);
          return createQueryable(filtered);
        };
      }
      if (prop === VALUES) {
        return () => Object.values(target);
      }
      return Reflect.get(target, prop, receiver);
    }
  });
}

function getRowPrototype(table) {
  if (!table._rowPrototype) {
    table._rowPrototype = { table };
    const features = Object.values(table._features);
    for (let i = 0; i < features.length; i++) {
      features[i].assignRowPrototype?.(table._rowPrototype, table);
    }
  }
  return table._rowPrototype;
}

export const constructRow = (table, id, original, rowIndex, depth, subRows, parentId) => {
  const row = Object.create(getRowPrototype(table));
  row._valuesCache = {};
  row.id = id;
  row.index = rowIndex;
  row.original = original;
  // ... 고유 데이터만 할당
  return row;
};

const queryablePrototype = {
  [WHERE]<T>(this: Queryable<T>, predicate: (value: T, key: string) => boolean): Queryable<T> {
    const out = Object.create(queryablePrototype) as Queryable<T>;
    for (const key in this) {
      if (!Object.prototype.hasOwnProperty.call(this, key)) continue;
      if (predicate(this[key], key)) out[key] = this[key];
    }
    return out;
  },
  [VALUES]<T>(this: Queryable<T>): T[] {
    return Object.values(this);
  },
  // SORT, MAP, SELECT, LIMIT, GROUP_BY, COUNT, FIRST ...
};

Object.freeze(queryablePrototype);

function createQueryable<T>(obj: Record<string, T>): Queryable<T> {
  const instance = Object.create(queryablePrototype) as Queryable<T>;
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      instance[key] = obj[key];
    }
  }
  return instance;
}

const { [WHERE]: where } = users;
where(u => u.age >= 20);  // TypeError: Cannot read properties of undefined

Object.keys(queryable);   // 데이터 키만 나온다 — DSL 명령이 보이지 않는다
{ ...queryable };         // 데이터는 복사되지만 메서드는 떨어진다
JSON.stringify(queryable); // 데이터만 직렬화된다

users
  [WHERE](u => u.age >= 20)
  [SORT]((a, b) => a.age - b.age)
  [VALUES]();

const WHERE = Symbol('where');
const SORT = Symbol('sort');
const MAP = Symbol('map');
const SELECT = Symbol('select');
const LIMIT = Symbol('limit');
const GROUP_BY = Symbol('group_by');
const COUNT = Symbol('count');
const FIRST = Symbol('first');
const VALUES = Symbol('values');

interface Queryable<T> {
  [WHERE]: (predicate: (value: T, key: string) => boolean) => Queryable<T>;
  [SORT]: (compareFn: (a: T, b: T) => number) => Queryable<T>;
  [MAP]: <U>(fn: (value: T, key: string) => U) => Queryable<U>;
  [SELECT]: (...keys: string[]) => Queryable<Partial<T>>;
  [LIMIT]: (n: number) => Queryable<T>;
  [GROUP_BY]: (keyFn: (value: T, key: string) => string) => Record<string, Queryable<T>>;
  [COUNT]: () => number;
  [FIRST]: () => T | undefined;
  [VALUES]: () => T[];

  [key: string]: T;
}

const queryablePrototype = {
  [WHERE]<T>(this: Queryable<T>, predicate: (value: T, key: string) => boolean): Queryable<T> {
    const out = Object.create(queryablePrototype) as Queryable<T>;
    for (const key in this) {
      if (!Object.prototype.hasOwnProperty.call(this, key)) continue;
      if (predicate(this[key], key)) out[key] = this[key];
    }
    return out;
  },
  [SORT]<T>(this: Queryable<T>, compareFn: (a: T, b: T) => number): Queryable<T> {
    const entries = Object.entries(this)
      .sort(([, a], [, b]) => compareFn(a as T, b as T));
    const out = Object.create(queryablePrototype) as Queryable<T>;
    for (const [key, value] of entries) out[key] = value as T;
    return out;
  },
  [MAP]<T, U>(this: Queryable<T>, fn: (value: T, key: string) => U): Queryable<U> {
    const out = Object.create(queryablePrototype) as Queryable<U>;
    for (const key in this) {
      if (!Object.prototype.hasOwnProperty.call(this, key)) continue;
      out[key] = fn(this[key], key);
    }
    return out;
  },
  [SELECT]<T>(this: Queryable<T>, ...keys: string[]): Queryable<Partial<T>> {
    const out = Object.create(queryablePrototype) as Queryable<Partial<T>>;
    for (const key of keys) {
      if (Object.prototype.hasOwnProperty.call(this, key)) out[key] = this[key];
    }
    return out;
  },
  [LIMIT]<T>(this: Queryable<T>, n: number): Queryable<T> {
    const entries = Object.entries(this).slice(0, n);
    const out = Object.create(queryablePrototype) as Queryable<T>;
    for (const [key, value] of entries) out[key] = value as T;
    return out;
  },
  [GROUP_BY]<T>(this: Queryable<T>, keyFn: (value: T, key: string) => string): Record<string, Queryable<T>> {
    const groups = Object.create(null) as Record<string, Queryable<T>>;
    for (const key in this) {
      if (!Object.prototype.hasOwnProperty.call(this, key)) continue;
      const groupKey = keyFn(this[key], key);
      if (!groups[groupKey]) groups[groupKey] = Object.create(queryablePrototype) as Queryable<T>;
      groups[groupKey][key] = this[key];
    }
    return groups;
  },
  [COUNT]<T>(this: Queryable<T>): number {
    let n = 0;
    for (const key in this) {
      if (Object.prototype.hasOwnProperty.call(this, key)) n++;
    }
    return n;
  },
  [FIRST]<T>(this: Queryable<T>): T | undefined {
    for (const key in this) {
      if (Object.prototype.hasOwnProperty.call(this, key)) return this[key];
    }
    return undefined;
  },
  [VALUES]<T>(this: Queryable<T>): T[] {
    return Object.values(this);
  },
};

Object.freeze(queryablePrototype);

function createQueryable<T>(obj: Record<string, T>): Queryable<T> {
  const instance = Object.create(queryablePrototype) as Queryable<T>;
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      instance[key] = obj[key];
    }
  }
  return instance;
}

const users = createQueryable({
  alice:   { name: 'Alice',   age: 25, dept: 'Engineering' },
  bob:     { name: 'Bob',     age: 30, dept: 'Design' },
  charlie: { name: 'Charlie', age: 20, dept: 'Engineering' },
  diana:   { name: 'Diana',   age: 35, dept: 'Design' },
});

// 25살 이상만 걸러내고 이름만 꺼낸다
const adultNames = users
  [WHERE](u => u.age >= 25)
  [MAP](u => u.name)
  [VALUES]();
// ['Alice', 'Bob', 'Diana']

const byDept = users[GROUP_BY](u => u.dept);
// {
//   Engineering: Queryable { alice: {...}, charlie: {...} },
//   Design:      Queryable { bob: {...}, diana: {...} }
// }

const engAdults = byDept.Engineering
  [WHERE](u => u.age >= 25)
  [VALUES]();
// [{ name: 'Alice', age: 25, dept: 'Engineering' }]

const youngest = users
  [SORT]((a, b) => a.age - b.age)
  [LIMIT](2)
  [SELECT]('name', 'age')
  [VALUES]();
// [{ name: 'Charlie', age: 20 }, { name: 'Alice', age: 25 }]

users[WHERE](u => u.dept === 'Engineering')[COUNT](); // 2
users[WHERE](u => u.age >= 30)[FIRST](); // { name: 'Bob', age: 30, dept: 'Design' }