[hygiene] Obfuscate protected methods

Author: jamesgpearce

coverage.json

@@ -1 +1 @@
-{"tests":7665,"assertions":32897,"lines":{"total":2596,"covered":2596,"skipped":0,"pct":100},"statements":{"total":2820,"covered":2820,"skipped":0,"pct":100},"functions":{"total":1146,"covered":1146,"skipped":0,"pct":100},"branches":{"total":974,"covered":974,"skipped":0,"pct":100},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":100}}
+{"tests":4555,"assertions":24950,"lines":{"total":2630,"covered":2617,"skipped":0,"pct":99.5},"statements":{"total":2859,"covered":2839,"skipped":0,"pct":99.3},"functions":{"total":1164,"covered":1144,"skipped":0,"pct":98.28},"branches":{"total":1012,"covered":1000,"skipped":0,"pct":98.81},"branchesTrue":{"total":0,"covered":0,"skipped":0,"pct":100}}

src/checkpoints/index.ts

@@ -43,6 +43,7 @@ import {objFreeze} from '../common/obj.ts';
 import {ifNotUndefined, isUndefined, size} from '../common/other.ts';
 import {IdSet2} from '../common/set.ts';
 import {EMPTY_STRING} from '../common/strings.ts';
+import {ProtectedStore} from '../index.ts';
 
 type CellsDelta = IdMap3<ChangedCell>;
 type ValuesDelta = IdMap<ChangedValue>;
@@ -76,7 +77,7 @@ export const createCheckpoints = getCreateFunction(
         collForEach(cellsDelta, (table, tableId) =>
           collForEach(table, (row, rowId) =>
             collForEach(row, (oldNew, cellId) =>
-              (store as any).setOrDelCell(
+              (store as ProtectedStore)._[5](
                 tableId,
                 rowId,
                 cellId,
@@ -87,7 +88,7 @@ export const createCheckpoints = getCreateFunction(
           ),
         );
         collForEach(valuesDelta, (oldNew, valueId) =>
-          (store as any).setOrDelValue(
+          (store as ProtectedStore)._[6](
             valueId,
             oldNew[oldOrNew] as ValueOrUndefined,
             true,

src/mergeable-store/index.ts

@@ -78,7 +78,17 @@ import {
   strEndsWith,
   strStartsWith,
 } from '../common/strings.ts';
-import {createStore} from '../store/index.ts';
+import {ProtectedStore, createStore} from '../store/index.ts';
+
+export type ProtectedMergeableStore = ProtectedStore & {__: ProtectedMethods};
+
+type ProtectedMethods = [
+  hadMutated: () => 0 | 1,
+  getEncodedMergeableContent: () => MergeableContent,
+  getEncodedTransactionMergeableChanges: (
+    withHashes: boolean,
+  ) => MergeableChanges<typeof withHashes>,
+];
 
 const LISTENER_ARGS: IdObj<number> = {
   HasTable: 1,
@@ -687,13 +697,14 @@ export const createMergeableStore = ((
     applyMergeableChanges,
     merge,
 
-    // only used internally by other modules
-    hadMutated,
-    getEncodedMergeableContent,
-    getEncodedTransactionMergeableChanges,
+    __: [
+      hadMutated,
+      getEncodedMergeableContent,
+      getEncodedTransactionMergeableChanges,
+    ] as ProtectedMethods,
   };
 
-  (store as any).setInternalListeners(
+  (store as ProtectedStore)._[3](
     preStartTransaction,
     preFinishTransaction,
     postFinishTransaction,

src/middleware/index.ts

@@ -36,6 +36,7 @@ import {getCreateFunction} from '../common/definable.ts';
 import {IdMap, mapEnsure, mapGet, mapNew} from '../common/map.ts';
 import {objFreeze} from '../common/obj.ts';
 import {ifNotUndefined, isUndefined} from '../common/other.ts';
+import {ProtectedStore} from '../store/index.ts';
 
 const reduceCallbacks = (
   callbacks: ((...args: any[]) => any)[],
@@ -190,7 +191,7 @@ export const createMiddleware = getCreateFunction(
       destroy,
     } as Middleware);
 
-    (store as any).setMiddleware(
+    (store as ProtectedStore)._[4](
       willSetContent,
       willSetTables,
       willSetTable,

src/persisters/common/create.ts

@@ -21,6 +21,8 @@ import {mapEnsure, mapGet, mapNew, mapSet} from '../../common/map.ts';
 import {objFreeze, objIsEmpty} from '../../common/obj.ts';
 import {errorNew, isArray, isUndefined, tryCatch} from '../../common/other.ts';
 import {IdSet2} from '../../common/set.ts';
+import {ProtectedMergeableStore} from '../../mergeable-store/index.ts';
+import {ProtectedStore} from '../../store/index.ts';
 
 const enum StatusValues {
   Idle = 0,
@@ -75,18 +77,20 @@ const getStoreFunctions = (
   persist != PersistsValues.StoreOnly && store.isMergeable()
     ? [
         1,
-        (store as any).getEncodedMergeableContent,
+        (store as ProtectedMergeableStore).__[1],
         () =>
-          (store as any).getEncodedTransactionMergeableChanges(!isSynchronizer),
+          (store as ProtectedMergeableStore).__[2](
+            !isSynchronizer,
+          ) as MergeableChanges<typeof isSynchronizer extends 1 ? false : true>,
         ([[changedTables], [changedValues]]: MergeableChanges) =>
           !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
         (store as MergeableStore).setDefaultContent,
       ]
     : persist != PersistsValues.MergeableStoreOnly
       ? [
           0,
-          (store as any).getEncodedContent,
-          (store as any).getEncodedTransactionChanges,
+          (store as ProtectedStore)._[7],
+          (store as ProtectedStore)._[8],
           ([changedTables, changedValues]: Changes) =>
             !objIsEmpty(changedTables) || !objIsEmpty(changedValues),
           store.setContent,
@@ -191,7 +195,7 @@ export const createCustomPersister = <
   };
 
   const saveAfterMutated = async (): Promise<void> => {
-    if (isAutoSaving() && (store as any).hadMutated?.()) {
+    if (isAutoSaving() && (store as ProtectedMergeableStore).__?.[0]?.()) {
       await save();
     }
   };

src/queries/index.ts

@@ -49,7 +49,6 @@ import {
   collSize3,
 } from '../common/coll.ts';
 import {getCreateFunction, getDefinableFunctions} from '../common/definable.ts';
-import {AddListener, CallListeners} from '../common/listeners.ts';
 import {
   IdMap,
   IdMap2,
@@ -92,6 +91,7 @@ import {
   SORTED_ROW_IDS,
   TABLE,
 } from '../common/strings.ts';
+import {ProtectedStore} from '../index.ts';
 
 type Build = (builders: {
   select: Select;
@@ -102,11 +102,6 @@ type Build = (builders: {
   param: Param;
 }) => void;
 
-type StoreWithPrivateMethods = Store & {
-  createStore: () => Store;
-  addListener: AddListener;
-  callListeners: CallListeners;
-};
 type SelectClause = (getTableCell: GetTableCell, rowId: Id) => CellOrUndefined;
 type JoinClause = [
   realTableId: Id,
@@ -127,18 +122,17 @@ type Aggregators = [
 ];
 
 export const createQueries = getCreateFunction((store: Store): Queries => {
-  const createStore = (store as StoreWithPrivateMethods).createStore;
+  const createStore = (store as ProtectedStore)._[0];
   const preStore = createStore();
   const resultStore = createStore();
   const preStoreListenerIds: Map<Id, Map<Store, IdSet>> = mapNew();
   const paramValuesListeners: IdSet2 = mapNew();
   const paramValueListeners: IdSet3 = mapNew();
 
   const {
-    addListener,
-    callListeners,
+    _: [, addListener, callListeners],
     delListener: delListenerImpl,
-  } = resultStore as StoreWithPrivateMethods;
+  } = resultStore as ProtectedStore;
   const [
     getStore,
     getQueryIds,
@@ -516,7 +510,7 @@ export const createQueries = getCreateFunction((store: Store): Queries => {
       selectJoinWhereStore.transaction(() =>
         arrayEvery(wheres, (where) => where(getTableCell))
           ? mapForEach(selects, (asCellId, tableCellGetter) =>
-              (selectJoinWhereStore as any).setOrDelCell(
+              (selectJoinWhereStore as ProtectedStore)._[5](
                 queryId,
                 rootRowId,
                 asCellId,

src/store/index.ts

@@ -68,6 +68,8 @@ import {
 import {defaultSorter} from '../common/index.ts';
 import {jsonParse, jsonStringWithMap} from '../common/json.ts';
 import {
+  AddListener,
+  CallListeners,
   ExtraArgsGetter,
   IdSetNode,
   PathGetters,
@@ -147,6 +149,67 @@ import {
   id,
 } from '../common/strings.ts';
 
+export type ProtectedStore = Store & {_: ProtectedMethods};
+
+type ProtectedMethods = [
+  createStore: () => Store,
+  addListener: AddListener,
+  callListeners: CallListeners,
+  setInternalListeners: (
+    preStartTransaction: () => void,
+    preFinishTransaction: () => void,
+    postFinishTransaction: () => void,
+    cellChanged: (
+      tableId: Id,
+      rowId: Id,
+      cellId: Id,
+      newCell: CellOrUndefined,
+      mutating: 0 | 1,
+    ) => void,
+    valueChanged: (
+      valueId: Id,
+      newValue: ValueOrUndefined,
+      mutating: 0 | 1,
+    ) => void,
+  ) => void,
+  setMiddleware: (
+    willSetContent: (content: Content) => Content | undefined,
+    willSetTables: (tables: Tables) => Tables | undefined,
+    willSetTable: (tableId: Id, table: Table) => Table | undefined,
+    willSetRow: (tableId: Id, rowId: Id, row: Row) => Row | undefined,
+    willSetCell: (
+      tableId: Id,
+      rowId: Id,
+      cellId: Id,
+      cell: Cell,
+    ) => CellOrUndefined,
+    willSetValues: (values: Values) => Values | undefined,
+    willSetValue: (valueId: Id, value: Value) => ValueOrUndefined,
+    willDelTables: () => boolean,
+    willDelTable: (tableId: Id) => boolean,
+    willDelRow: (tableId: Id, rowId: Id) => boolean,
+    willDelCell: (tableId: Id, rowId: Id, cellId: Id) => boolean,
+    willDelValues: () => boolean,
+    willDelValue: (valueId: Id) => boolean,
+    willApplyChanges: (changes: Changes) => Changes | undefined,
+    didSetRow: (tableId: Id, rowId: Id, oldRow: Row, newRow: Row) => Row,
+  ) => void,
+  setOrDelCell: (
+    tableId: Id,
+    rowId: Id,
+    cellId: Id,
+    cell: CellOrUndefined,
+    skipMiddleware?: boolean,
+  ) => Store,
+  setOrDelValue: (
+    valueId: Id,
+    value: ValueOrUndefined,
+    skipMiddleware?: boolean,
+  ) => Store,
+  getEncodedContent: () => Content,
+  getEncodedTransactionChanges: () => Changes,
+];
+
 type TablesSchemaMap = IdMap2<CellSchema>;
 type ValuesSchemaMap = IdMap<ValueSchema>;
 type RowMap = IdMap<Cell>;
@@ -2152,16 +2215,17 @@ export const createStore: typeof createStoreDecl = (): Store => {
 
     isMergeable: () => false,
 
-    // only used internally by other modules
-    createStore,
-    addListener,
-    callListeners,
-    setInternalListeners,
-    setMiddleware,
-    setOrDelCell,
-    setOrDelValue,
-    getEncodedContent,
-    getEncodedTransactionChanges,
+    _: [
+      createStore,
+      addListener,
+      callListeners,
+      setInternalListeners,
+      setMiddleware,
+      setOrDelCell,
+      setOrDelValue,
+      getEncodedContent,
+      getEncodedTransactionChanges,
+    ] as ProtectedMethods,
   };
 
   // and now for some gentle meta-programming