tinybase 2.2.0-beta.0 → 2.2.0-beta.1

package/lib/debug/tools.js

@@ -20,8 +20,6 @@ const arrayShift = (array) => array.shift();
 const jsonParse = JSON.parse;
 const isFiniteNumber = isFinite;
 const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
 const isString = (thing) => getTypeOf(thing) == STRING;
 const isArray = (thing) => Array.isArray(thing);
@@ -82,7 +80,8 @@ ${text.replace(
 )}${indent} */`;
   });
 const length = (str) => str.length;
-const join = (str, sep = EMPTY_STRING) => str.join(sep);
+const join = (array, sep = EMPTY_STRING) => array.join(sep);
+const flat = (array) => array.flat(1e3);
 const camel = (str, firstCap = 0) =>
   join(
     arrayMap(
@@ -99,22 +98,13 @@ const getCodeFunctions = () => {
   const types = mapNew();
   const methods = mapNew();
   const constants = mapNew();
-  const build = (...lines) => {
-    const allLines = [];
-    const handleLine = (line) =>
-      isArray(line)
-        ? arrayForEach(line, handleLine)
-        : arrayPush(allLines, line);
-    arrayForEach(lines, handleLine);
-    return allLines.join('\n');
-  };
+  const build = (...lines) => join(flat(lines), '\n');
   const addImport = (location, source, ...items) =>
     arrayForEach(items, (item) =>
       setAdd(mapEnsure(allImports[location], source, setNew), item),
     );
   const addType = (name, body = '', doc = '') =>
     mapUnique(types, name, [body, doc]);
-  const updateType = (name, body, doc) => mapSet(types, name, [body, doc]);
   const addMethod = (name, parameters, returnType, body, doc, generic = '') =>
     mapUnique(methods, name, [parameters, returnType, body, doc, generic]);
   const addFunction = (name, parameters, body) =>
@@ -167,7 +157,6 @@ const getCodeFunctions = () => {
     build,
     addImport,
     addType,
-    updateType,
     addMethod,
     addFunction,
     addConstant,
@@ -181,10 +170,8 @@ const getCodeFunctions = () => {
 const object = Object;
 const objIds = object.keys;
 const objFreeze = object.freeze;
-const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objHas = (obj, id) => !isUndefined(objGet(obj, id));
-const objForEach = (obj, cb) =>
-  arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
+const objMap = (obj, cb) =>
+  arrayMap(object.entries(obj), ([id, value]) => cb(value, id));
 const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
 
 const getCellType = (cell) => {
@@ -204,16 +191,22 @@ const getCreateFunction = (getFunction) => {
   };
 };
 
+const THE_CONTENT_OF = 'the content of';
 const THE_STORE = 'the Store';
+const A_FUNCTION_FOR = 'A function for';
+const EXPORT = 'export';
+const LISTENER = 'listener';
+const OR_UNDEFINED = ' | undefined';
+const REGISTERS_A_LISTENER = `Registers a ${LISTENER} that will be called`;
 const REPRESENTS = 'Represents';
-const THE_CONTENT_OF = 'the content of';
+const RETURNS_VOID = ' => void';
 const THE_CONTENT_OF_THE_STORE = `${THE_CONTENT_OF} ${THE_STORE}`;
+const THE_END_OF_THE_TRANSACTION = 'the end of the transaction';
 const THE_SPECIFIED_ROW = 'the specified Row';
-const REGISTERS_A_LISTENER = 'Registers a listener that will be called';
-const storeMethod = (method, parameters = '', cast = '') =>
-  `store.${method}(${parameters})${cast ? ` as ${cast}` : ''}`;
-const fluentStoreMethod = (method, parameters = '') =>
-  `fluent(() => ${storeMethod(method, parameters)})`;
+const getRowTypeDoc = (tableId, set = 0) =>
+  `${REPRESENTS} a Row when ${
+    set ? 's' : 'g'
+  }etting ${THE_CONTENT_OF} the '${tableId}' Table`;
 const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
   `Gets ${
     sorted ? 'sorted, paginated' : 'the'
@@ -223,41 +216,67 @@ const getForEachDoc = (childNoun, parentNoun) =>
 const getHasDoc = (childNoun, parentNoun = THE_STORE) =>
   `Gets whether ${childNoun} exists in ${parentNoun}`;
 const getCallbackDoc = (takes) => `A function that takes ${takes}`;
+const getListenerTypeDoc = (childNoun = 0, parentNoun = 0) =>
+  `${A_FUNCTION_FOR} listening to changes to ${nouns[childNoun]} in ${nouns[parentNoun]}`;
 const getListenerDoc = (childNoun, parentNoun, pluralChild = 0) =>
   `${REGISTERS_A_LISTENER} whenever ${childNoun} in ${parentNoun} change` +
   (pluralChild ? '' : 's');
-const getVerb = (verb = 0) =>
-  verb == 1
-    ? 'Sets'
-    : verb == 2
-    ? 'Sets part of'
-    : verb == 3
-    ? 'Deletes'
-    : 'Gets';
+const getStoreContentDoc = (verb = 0) =>
+  `${verbs[verb]} ${THE_CONTENT_OF_THE_STORE}`;
+const getTableDoc = (tableId) => `the '${tableId}' Table`;
+const getRowDoc = (tableId) =>
+  `${THE_SPECIFIED_ROW} in ${getTableDoc(tableId)}`;
+const getCellDoc = (cellId) => `the '${cellId}' Cell`;
+const getTableContentDoc = (tableId, verb = 0) =>
+  `${verbs[verb]} ${THE_CONTENT_OF} ${getTableDoc(tableId)}`;
+const getRowContentDoc = (tableId, verb = 0) =>
+  `${verbs[verb]} ${THE_CONTENT_OF} ${getRowDoc(tableId)}`;
+const getCellContentDoc = (tableId, cellId, verb = 0) =>
+  `${verbs[verb]} ${getCellDoc(cellId)} for ${getRowDoc(tableId)}`;
+const verbs = ['Gets', 'Sets', 'Sets part of', 'Deletes'];
+const nouns = [
+  THE_STORE,
+  'anything',
+  'Table Ids',
+  'a Table',
+  'Row Ids',
+  'a Row',
+  'Cell Ids',
+  'a Cell',
+  'invalid Cell changes',
+];
+
+const COMMON_IMPORTS = [
+  'ChangedCells',
+  'Id',
+  'IdOrNull',
+  'Ids',
+  'InvalidCells',
+  'Json',
+  'Store',
+];
+const storeMethod = (method, parameters = EMPTY_STRING, cast = EMPTY_STRING) =>
+  `store.${method}(${parameters})${cast ? ` as ${cast}` : EMPTY_STRING}`;
+const fluentStoreMethod = (method, parameters = EMPTY_STRING) =>
+  `fluent(() => ${storeMethod(method, parameters)})`;
+const storeListener = (
+  method,
+  beforeParameters = EMPTY_STRING,
+  afterParameters = EMPTY_STRING,
+) =>
+  `store.${method}(${
+    beforeParameters ? `${beforeParameters}, ` : EMPTY_STRING
+  }proxy(${LISTENER})${
+    afterParameters ? `, ${afterParameters}` : EMPTY_STRING
+  })`;
 const getStoreApi = (schema, module) => {
   if (objIsEmpty(schema)) {
-    return pairNew('// store has no inferable schema');
+    return pairNew(EMPTY_STRING);
   }
-  const moduleName = camel(module);
-  const storeType = camel(module, 1);
-  const storeInstance = camel(storeType);
-  const returnStore = `return ${storeInstance};`;
-  const tablesTypes = [];
-  const tableIdTypes = [];
-  const tableCallbackArgTypes = [];
-  const getCellChangeArgTypes = [];
-  const cellListenerArgTypes = [];
-  const allCellIdType = [];
-  const schemaLines = [];
-  const storeListener = (method, beforeParameters = '', afterParameters = '') =>
-    `store.${method}(${
-      beforeParameters ? `${beforeParameters}, ` : ''
-    }proxy(listener)${afterParameters ? `, ${afterParameters}` : ''})`;
   const [
     build,
     addImport,
     addType,
-    updateType,
     addMethod,
     addFunction,
     addConstant,
@@ -266,113 +285,198 @@ const getStoreApi = (schema, module) => {
     getMethods,
     getConstants,
   ] = getCodeFunctions();
-  addImport(
-    0,
-    'tinybase',
-    'CellChange',
-    'ChangedCells',
-    'Id',
-    'IdOrNull',
-    'Ids',
-    'InvalidCells',
-    'Json',
-    'Store',
+  const moduleDefinition = `./${camel(module)}.d`;
+  const storeType = camel(module, 1);
+  const storeInstance = camel(storeType);
+  const tableTypes = mapNew();
+  const mapTableSchema = (callback) =>
+    objMap(schema, (_, tableId) => {
+      return callback(
+        tableId,
+        mapEnsure(tableTypes, tableId, () => {
+          const table = camel(tableId, 1);
+          return [
+            addType(
+              `${table}Table`,
+              `{[rowId: Id]: ${table}Row}`,
+              `${REPRESENTS} the '${tableId}' Table`,
+            ),
+            addType(
+              `${table}Row`,
+              `{${join(
+                mapCellSchema(
+                  tableId,
+                  (cellId, type, defaultValue) =>
+                    `'${cellId}'${
+                      isUndefined(defaultValue) ? '?' : EMPTY_STRING
+                    }: ${type};`,
+                ),
+                ' ',
+              )}}`,
+              getRowTypeDoc(tableId),
+            ),
+            addType(
+              `${table}RowWhenSet`,
+              `{${join(
+                mapCellSchema(
+                  tableId,
+                  (cellId, type) => `'${cellId}'?: ${type};`,
+                ),
+                ' ',
+              )}}`,
+              getRowTypeDoc(tableId, 1),
+            ),
+            addType(
+              `${table}CellId`,
+              join(
+                mapCellSchema(tableId, (cellId) => `'${cellId}'`),
+                ' | ',
+              ),
+              `A Cell Id for the '${tableId}' Table`,
+            ),
+            addType(
+              `${table}CellCallback`,
+              `(...[cellId, cell]: ${join(
+                mapCellSchema(
+                  tableId,
+                  (cellId, type) => `[cellId: '${cellId}', cell: ${type}]`,
+                ),
+                ' | ',
+              )})${RETURNS_VOID}`,
+              getCallbackDoc(
+                `a Cell Id and value from a Row in the '${tableId}' Table`,
+              ),
+            ),
+            addType(
+              `${table}RowCallback`,
+              `(rowId: Id, forEachCell: (cellCallback: ${table}CellCallback)${RETURNS_VOID})${RETURNS_VOID}`,
+              getCallbackDoc(
+                `a Row Id from the '${tableId}' Table, and a Cell iterator`,
+              ),
+            ),
+          ];
+        }),
+        camel(tableId, 1),
+        addConstant(snake(tableId), `'${tableId}'`),
+      );
+    });
+  const mapCellSchema = (tableId, callback) =>
+    objMap(schema[tableId], (cellSchema, cellId) =>
+      callback(
+        cellId,
+        cellSchema[TYPE],
+        cellSchema[DEFAULT],
+        addConstant(snake(cellId), `'${cellId}'`),
+        camel(cellId, 1),
+      ),
+    );
+  const tablesType = addType(
+    'Tables',
+    `{${join(
+      mapTableSchema(
+        (tableId, tableTypes2) => `'${tableId}'?: ${tableTypes2[0]};`,
+      ),
+      ' ',
+    )}}`,
+    `${REPRESENTS} ${THE_CONTENT_OF_THE_STORE}`,
   );
-  addImport(
-    1,
-    'tinybase',
-    'ChangedCells',
-    'Id',
-    'IdOrNull',
-    'Ids',
-    'InvalidCells',
-    'Json',
-    'Store',
-    'createStore',
+  const tableIdType = addType(
+    'TableId',
+    join(
+      mapTableSchema((tableId) => `'${tableId}'`),
+      ' | ',
+    ),
+    `A Table Id in ${THE_STORE}`,
+  );
+  const tableCallbackType = addType(
+    'TableCallback',
+    `(...[tableId, rowCallback]: ${join(
+      mapTableSchema(
+        (tableId, tableTypes2) =>
+          `[tableId: '${tableId}', forEachRow: (rowCallback: ${tableTypes2[5]})${RETURNS_VOID}]`,
+      ),
+      ' | ',
+    )})${RETURNS_VOID}`,
+    getCallbackDoc('a Table Id, and a Row iterator'),
+  );
+  const getCellChangeType = addType(
+    'GetCellChange',
+    `(...[tableId, rowId, cellId]: ${join(
+      mapTableSchema(
+        (tableId, tableTypes2) =>
+          `[tableId: '${tableId}', rowId: Id, cellId: ${tableTypes2[3]}]`,
+      ),
+      ' | ',
+    )}) => CellChange`,
+    `${A_FUNCTION_FOR} returning information about any Cell's changes during  a transaction`,
   );
-  addFunction('fluent', 'actions: () => Store', ['actions();', returnStore]);
-  addFunction(
-    'proxy',
-    `listener: any`,
-    `(_: Store, ...args: any[]) => listener(${storeInstance}, ...args)`,
-  );
-  const TYPE2 = addConstant(snake(TYPE), `'${TYPE}'`);
-  const DEFAULT2 = addConstant(snake(DEFAULT), `'${DEFAULT}'`);
-  const tablesType = addType('Tables');
-  const tableIdType = addType('TableId');
-  const tableCallbackType = addType('TableCallback');
-  const getCellChangeType = addType('GetCellChange');
   const tablesListenerType = addType(
     'TablesListener',
-    `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType} | undefined) => void`,
-    `A function for listening to changes to ${THE_CONTENT_OF_THE_STORE}`,
+    `(${storeInstance}: ${storeType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+    getListenerTypeDoc(1),
   );
   const tableIdsListenerType = addType(
     'TableIdsListener',
-    `(${storeInstance}: ${storeType}) => void`,
-    `A function for listening to changes to Table Ids in ${THE_STORE}`,
+    `(${storeInstance}: ${storeType})${RETURNS_VOID}`,
+    getListenerTypeDoc(2),
   );
   const tableListenerType = addType(
     'TableListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType} | undefined) => void`,
-    `A function for listening to changes to a Table in ${THE_STORE}`,
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+    getListenerTypeDoc(3),
   );
   const rowIdsListenerType = addType(
     'RowIdsListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}) => void`,
-    `A function for listening to changes to Row Ids in ${THE_STORE}`,
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType})${RETURNS_VOID}`,
+    getListenerTypeDoc(4, 3),
   );
   const rowListenerType = addType(
     'RowListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType} | undefined) => void`,
-    `A function for listening to changes to a Row in ${THE_STORE}`,
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id, getCellChange: ${getCellChangeType}${OR_UNDEFINED})${RETURNS_VOID}`,
+    getListenerTypeDoc(5, 3),
   );
   const cellIdsListenerType = addType(
     'CellIdsListener',
-    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id) => void`,
-    `A function for listening to changes to Cell Ids in ${THE_STORE}`,
+    `(${storeInstance}: ${storeType}, tableId: ${tableIdType}, rowId: Id)` +
+      RETURNS_VOID,
+    getListenerTypeDoc(6, 5),
+  );
+  const cellListenerType = addType(
+    'CellListener',
+    `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
+      flat(
+        mapTableSchema((tableId) =>
+          mapCellSchema(
+            tableId,
+            (cellId, type) =>
+              `[${storeInstance}: ${storeType}, tableId: '${tableId}', rowId: Id, cellId: '${cellId}', newCell: ${type}${OR_UNDEFINED}, oldCell: ${type}${OR_UNDEFINED}, getCellChange: ${getCellChangeType} | undefined]`,
+          ),
+        ),
+      ),
+      ' | ',
+    )})${RETURNS_VOID}`,
+    getListenerTypeDoc(7, 5),
   );
-  const cellListenerType = addType('CellListener');
   const invalidCellListenerType = addType(
     'InvalidCellListener',
-    `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[]) => void;`,
-    `A function for listening to invalid Cell changes`,
+    `(${storeInstance}: ${storeType}, tableId: Id, rowId: Id, cellId: Id, invalidCells: any[])${RETURNS_VOID};`,
+    getListenerTypeDoc(8),
   );
   const transactionListenerType = addType(
     'TransactionListener',
-    `(${storeInstance}: ${storeType}, cellsTouched: boolean) => void;`,
-    `A function for listening to the completion of a transaction`,
-  );
-  addImport(
-    1,
-    `./${moduleName}.d`,
-    storeType,
-    `create${storeType} as create${storeType}Decl`,
-    tablesType,
-    tableIdType,
-    tableCallbackType,
-    tablesListenerType,
-    tableIdsListenerType,
-    tableListenerType,
-    rowIdsListenerType,
-    rowListenerType,
-    cellIdsListenerType,
-    cellListenerType,
-    invalidCellListenerType,
-    transactionListenerType,
+    `(${storeInstance}: ${storeType}, cellsTouched: boolean)${RETURNS_VOID};`,
+    `${A_FUNCTION_FOR} listening to the completion of a transaction`,
   );
-  const getStoreContentDoc = (verb = 0) =>
-    `${getVerb(verb)} ${THE_CONTENT_OF_THE_STORE}`;
   addMethod(
     `hasTables`,
-    '',
+    EMPTY_STRING,
     BOOLEAN,
     storeMethod('hasTables'),
     getHasDoc('any Table'),
   );
   addMethod(
     `getTables`,
-    '',
+    EMPTY_STRING,
     tablesType,
     storeMethod('getTables'),
     getStoreContentDoc(),
@@ -386,16 +490,16 @@ const getStoreApi = (schema, module) => {
   );
   addMethod(
     `delTables`,
-    '',
+    EMPTY_STRING,
     storeType,
     fluentStoreMethod('delTables'),
     getStoreContentDoc(3),
   );
   addMethod(
     `getTableIds`,
-    '',
+    EMPTY_STRING,
     `${tableIdType}[]`,
-    storeMethod('getTableIds', '', `${tableIdType}[]`),
+    storeMethod('getTableIds', EMPTY_STRING, `${tableIdType}[]`),
     getIdsDoc('Table', THE_STORE),
   );
   addMethod(
@@ -406,266 +510,198 @@ const getStoreApi = (schema, module) => {
     getForEachDoc('Table', THE_STORE),
   );
   const mapCellTypes = mapNew();
-  objForEach(schema, (cellSchemas, tableId) => {
-    const table = camel(tableId, 1);
-    const TABLE_ID = addConstant(snake(tableId), `'${tableId}'`);
-    const getCellsTypes = [];
-    const setCellsTypes = [];
-    const cellIdTypes = [];
-    const cellCallbackArgTypes = [];
-    const tableDoc = `the '${tableId}' Table`;
-    const rowDoc = `${THE_SPECIFIED_ROW} in ${tableDoc}`;
-    const tableContentDoc = `${THE_CONTENT_OF} ${tableDoc}`;
-    const getTableContentDoc = (verb = 0) =>
-      `${getVerb(verb)} ${THE_CONTENT_OF} ${tableDoc}`;
-    const getRowContentDoc = (verb = 0) =>
-      `${getVerb(verb)} ${THE_CONTENT_OF} ${rowDoc}`;
-    const getRowTypeDoc = (set = 0) =>
-      `${REPRESENTS} a Row when ${set ? 's' : 'g'}etting ${tableContentDoc}`;
-    const tableType = addType(
-      `${table}Table`,
-      `{[rowId: Id]: ${table}Row}`,
-      `${REPRESENTS} ${tableDoc}`,
-    );
-    const rowType = addType(`${table}Row`);
-    const rowWhenSetType = addType(`${table}RowWhenSet`);
-    const cellIdType = addType(`${table}CellId`);
-    const cellCallbackType = addType(`${table}CellCallback`);
-    const rowCallbackType = addType(`${table}RowCallback`);
-    addImport(
-      1,
-      `./${moduleName}.d`,
-      tableType,
-      rowType,
-      rowWhenSetType,
-      cellIdType,
-      cellCallbackType,
-      rowCallbackType,
-    );
-    addMethod(
-      `has${table}Table`,
-      '',
-      BOOLEAN,
-      storeMethod('hasTable', TABLE_ID),
-      getHasDoc(tableDoc),
-    );
-    addMethod(
-      `get${table}Table`,
-      '',
-      tableType,
-      storeMethod('getTable', TABLE_ID, tableType),
-      getTableContentDoc(),
-    );
-    addMethod(
-      `set${table}Table`,
-      `table: ${tableType}`,
-      storeType,
-      fluentStoreMethod('setTable', `${TABLE_ID}, table`),
-      getTableContentDoc(1),
-    );
-    addMethod(
-      `del${table}Table`,
-      '',
-      storeType,
-      fluentStoreMethod('delTable', TABLE_ID),
-      getTableContentDoc(3),
-    );
-    addMethod(
-      `get${table}RowIds`,
-      '',
-      'Ids',
-      storeMethod('getRowIds', TABLE_ID),
-      getIdsDoc('Row', tableDoc),
-    );
-    addMethod(
-      `get${table}SortedRowIds`,
-      `cellId?: ${cellIdType}, descending?: boolean, offset?: number, limit?: number`,
-      'Ids',
-      storeMethod(
-        'getSortedRowIds',
-        `${TABLE_ID}, cellId, descending, offset, limit`,
-      ),
-      getIdsDoc('Row', tableDoc, 1),
-    );
-    addMethod(
-      `forEach${table}Row`,
-      `rowCallback: ${rowCallbackType}`,
-      'void',
-      storeMethod('forEachRow', `${TABLE_ID}, rowCallback as any`),
-      getForEachDoc('Row', tableDoc),
-    );
-    addMethod(
-      `has${table}Row`,
-      'rowId: Id',
-      BOOLEAN,
-      storeMethod('hasRow', `${TABLE_ID}, rowId`),
-      getHasDoc(THE_SPECIFIED_ROW, tableDoc),
-    );
-    addMethod(
-      `get${table}Row`,
-      'rowId: Id',
-      rowType,
-      storeMethod('getRow', `${TABLE_ID}, rowId`, rowType),
-      getRowContentDoc(),
-    );
-    addMethod(
-      `set${table}Row`,
-      `rowId: Id, row: ${rowWhenSetType}`,
-      storeType,
-      fluentStoreMethod('setRow', `${TABLE_ID}, rowId, row`),
-      getRowContentDoc(1),
-    );
-    addMethod(
-      `add${table}Row`,
-      `row: ${rowWhenSetType}`,
-      'Id | undefined',
-      storeMethod('addRow', `${TABLE_ID}, row`),
-      `Adds a new Row to ${tableDoc}`,
-    );
-    addMethod(
-      `set${table}PartialRow`,
-      `rowId: Id, partialRow: ${rowWhenSetType}`,
-      storeType,
-      fluentStoreMethod('setPartialRow', `${TABLE_ID}, rowId, partialRow`),
-      getRowContentDoc(2),
-    );
-    addMethod(
-      `del${table}Row`,
-      `rowId: Id`,
-      storeType,
-      fluentStoreMethod('delRow', `${TABLE_ID}, rowId`),
-      getRowContentDoc(3),
-    );
-    addMethod(
-      `get${table}CellIds`,
-      'rowId: Id',
-      `${cellIdType}[]`,
-      storeMethod('getCellIds', `${TABLE_ID}, rowId`, `${cellIdType}[]`),
-      getIdsDoc('Cell', rowDoc),
-    );
-    addMethod(
-      `forEach${table}Cell`,
-      `rowId: Id, cellCallback: ${cellCallbackType}`,
-      'void',
-      storeMethod('forEachCell', `${TABLE_ID}, rowId, cellCallback as any`),
-      getForEachDoc('Cell', rowDoc),
-    );
-    arrayPush(schemaLines, `[${TABLE_ID}]: {`);
-    objForEach(cellSchemas, (cellSchema, cellId) => {
-      const cell = camel(cellId, 1);
-      const CELL_ID = addConstant(snake(cellId), `'${cellId}'`);
-      const type = cellSchema[TYPE];
-      const defaulted = objHas(cellSchema, DEFAULT);
-      const defaultValue = cellSchema[DEFAULT];
-      const cellDoc = `the '${cellId}' Cell`;
-      const getCellContentDoc = (verb = 0) =>
-        `${getVerb(verb)} ${cellDoc} for ${rowDoc}`;
-      arrayPush(
-        schemaLines,
-        `[${CELL_ID}]: {[${TYPE2}]: ${addConstant(snake(type), `'${type}'`)}${
-          defaulted
-            ? `, [${DEFAULT2}]: ${
-                isString(defaultValue)
-                  ? addConstant(snake(defaultValue), `'${defaultValue}'`)
-                  : defaultValue
-              }`
-            : ''
-        }},`,
+  mapTableSchema(
+    (
+      tableId,
+      [
+        tableType,
+        rowType,
+        rowWhenSetType,
+        cellIdType,
+        cellCallbackType,
+        rowCallbackType,
+      ],
+      tableName,
+      TABLE_ID,
+    ) => {
+      addImport(
+        1,
+        moduleDefinition,
+        tableType,
+        rowType,
+        rowWhenSetType,
+        cellIdType,
+        cellCallbackType,
+        rowCallbackType,
+      );
+      addMethod(
+        `has${tableName}Table`,
+        EMPTY_STRING,
+        BOOLEAN,
+        storeMethod('hasTable', TABLE_ID),
+        getHasDoc(getTableDoc(tableId)),
+      );
+      addMethod(
+        `get${tableName}Table`,
+        EMPTY_STRING,
+        tableType,
+        storeMethod('getTable', TABLE_ID, tableType),
+        getTableContentDoc(tableId),
+      );
+      addMethod(
+        `set${tableName}Table`,
+        `table: ${tableType}`,
+        storeType,
+        fluentStoreMethod('setTable', `${TABLE_ID}, table`),
+        getTableContentDoc(tableId, 1),
+      );
+      addMethod(
+        `del${tableName}Table`,
+        EMPTY_STRING,
+        storeType,
+        fluentStoreMethod('delTable', TABLE_ID),
+        getTableContentDoc(tableId, 3),
+      );
+      addMethod(
+        `get${tableName}RowIds`,
+        EMPTY_STRING,
+        'Ids',
+        storeMethod('getRowIds', TABLE_ID),
+        getIdsDoc('Row', getTableDoc(tableId)),
       );
-      arrayPush(getCellsTypes, `'${cellId}'${defaulted ? '' : '?'}: ${type};`);
-      arrayPush(setCellsTypes, `'${cellId}'?: ${type};`);
-      arrayPush(cellIdTypes, `'${cellId}'`);
-      arrayPush(cellCallbackArgTypes, `[cellId: '${cellId}', cell: ${type}]`);
-      arrayPush(
-        cellListenerArgTypes,
-        `[${storeInstance}: ${storeType}, tableId: '${tableId}', rowId: Id, cellId: '${cellId}', newCell: ${type} | undefined, oldCell: ${type} | undefined, getCellChange: ${getCellChangeType} | undefined]`,
+      addMethod(
+        `get${tableName}SortedRowIds`,
+        `cellId?: ${cellIdType}, descending?: boolean, offset?: number, limit?: number`,
+        'Ids',
+        storeMethod(
+          'getSortedRowIds',
+          `${TABLE_ID}, cellId, descending, offset, limit`,
+        ),
+        getIdsDoc('Row', getTableDoc(tableId), 1),
       );
-      const mapCellType = `Map${camel(type, 1)}`;
-      mapSet(mapCellTypes, type, mapCellType);
       addMethod(
-        `has${table}${cell}Cell`,
+        `forEach${tableName}Row`,
+        `rowCallback: ${rowCallbackType}`,
+        'void',
+        storeMethod('forEachRow', `${TABLE_ID}, rowCallback as any`),
+        getForEachDoc('Row', getTableDoc(tableId)),
+      );
+      addMethod(
+        `has${tableName}Row`,
         'rowId: Id',
         BOOLEAN,
-        storeMethod('hasCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
-        getHasDoc(cellDoc, rowDoc),
+        storeMethod('hasRow', `${TABLE_ID}, rowId`),
+        getHasDoc(THE_SPECIFIED_ROW, getTableDoc(tableId)),
       );
-      const returnCellType = `${type}${defaulted ? '' : ' | undefined'}`;
       addMethod(
-        `get${table}${cell}Cell`,
+        `get${tableName}Row`,
         'rowId: Id',
-        returnCellType,
-        storeMethod(
-          'getCell',
-          `${TABLE_ID}, rowId, ${CELL_ID}`,
-          returnCellType,
-        ),
-        getCellContentDoc(),
+        rowType,
+        storeMethod('getRow', `${TABLE_ID}, rowId`, rowType),
+        getRowContentDoc(tableId),
       );
       addMethod(
-        `set${table}${cell}Cell`,
-        `rowId: Id, cell: ${type} | ${mapCellType}`,
+        `set${tableName}Row`,
+        `rowId: Id, row: ${rowWhenSetType}`,
         storeType,
-        fluentStoreMethod(
-          'setCell',
-          `${TABLE_ID}, rowId, ${CELL_ID}, cell as any`,
-        ),
-        getCellContentDoc(1),
+        fluentStoreMethod('setRow', `${TABLE_ID}, rowId, row`),
+        getRowContentDoc(tableId, 1),
       );
       addMethod(
-        `del${table}${cell}Cell`,
+        `add${tableName}Row`,
+        `row: ${rowWhenSetType}`,
+        `Id${OR_UNDEFINED}`,
+        storeMethod('addRow', `${TABLE_ID}, row`),
+        `Adds a new Row to ${getTableDoc(tableId)}`,
+      );
+      addMethod(
+        `set${tableName}PartialRow`,
+        `rowId: Id, partialRow: ${rowWhenSetType}`,
+        storeType,
+        fluentStoreMethod('setPartialRow', `${TABLE_ID}, rowId, partialRow`),
+        getRowContentDoc(tableId, 2),
+      );
+      addMethod(
+        `del${tableName}Row`,
         `rowId: Id`,
         storeType,
-        fluentStoreMethod('delCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
-        getCellContentDoc(3),
+        fluentStoreMethod('delRow', `${TABLE_ID}, rowId`),
+        getRowContentDoc(tableId, 3),
       );
-    });
-    arrayPush(schemaLines, `},`);
-    arrayPush(tablesTypes, `'${tableId}'?: ${tableType};`);
-    arrayPush(tableIdTypes, `'${tableId}'`);
-    arrayPush(
-      tableCallbackArgTypes,
-      `[tableId: '${tableId}', forEachRow: (rowCallback: ${rowCallbackType}) => void]`,
-    );
-    arrayPush(
-      getCellChangeArgTypes,
-      `[tableId: '${tableId}', rowId: Id, cellId: ${cellIdType}]`,
-    );
-    arrayPush(allCellIdType, cellIdType);
-    updateType(rowType, `{${join(getCellsTypes, ' ')}}`, getRowTypeDoc());
-    updateType(
-      rowWhenSetType,
-      `{${join(setCellsTypes, ' ')}}`,
-      getRowTypeDoc(1),
-    );
-    updateType(
-      cellIdType,
-      join(cellIdTypes, ' | '),
-      `A Cell Id for ${tableDoc}`,
-    );
-    updateType(
-      cellCallbackType,
-      `(...[cellId, cell]: ${join(cellCallbackArgTypes, ' | ')}) => void`,
-      getCallbackDoc(`a Cell Id and value from a Row in ${tableDoc}`),
-    );
-    updateType(
-      rowCallbackType,
-      `(rowId: Id, forEachCell: (cellCallback: ${cellCallbackType}) => void) => void`,
-      getCallbackDoc(`a Row Id from ${tableDoc}, and a Cell iterator`),
-    );
-  });
+      addMethod(
+        `get${tableName}CellIds`,
+        'rowId: Id',
+        `${cellIdType}[]`,
+        storeMethod('getCellIds', `${TABLE_ID}, rowId`, `${cellIdType}[]`),
+        getIdsDoc('Cell', getRowDoc(tableId)),
+      );
+      addMethod(
+        `forEach${tableName}Cell`,
+        `rowId: Id, cellCallback: ${cellCallbackType}`,
+        'void',
+        storeMethod('forEachCell', `${TABLE_ID}, rowId, cellCallback as any`),
+        getForEachDoc('Cell', getRowDoc(tableId)),
+      );
+      mapCellSchema(
+        tableId,
+        (cellId, type, defaultValue, CELL_ID, cellName) => {
+          const mapCellType = `Map${camel(type, 1)}`;
+          mapSet(mapCellTypes, type, mapCellType);
+          addMethod(
+            `has${tableName}${cellName}Cell`,
+            'rowId: Id',
+            BOOLEAN,
+            storeMethod('hasCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+            getHasDoc(getCellDoc(cellId), getRowDoc(tableId)),
+          );
+          const returnCellType = `${type}${
+            isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING
+          }`;
+          addMethod(
+            `get${tableName}${cellName}Cell`,
+            'rowId: Id',
+            returnCellType,
+            storeMethod(
+              'getCell',
+              `${TABLE_ID}, rowId, ${CELL_ID}`,
+              returnCellType,
+            ),
+            getCellContentDoc(tableId, cellId),
+          );
+          addMethod(
+            `set${tableName}${cellName}Cell`,
+            `rowId: Id, cell: ${type} | ${mapCellType}`,
+            storeType,
+            fluentStoreMethod(
+              'setCell',
+              `${TABLE_ID}, rowId, ${CELL_ID}, cell as any`,
+            ),
+            getCellContentDoc(tableId, cellId, 1),
+          );
+          addMethod(
+            `del${tableName}${cellName}Cell`,
+            `rowId: Id`,
+            storeType,
+            fluentStoreMethod('delCell', `${TABLE_ID}, rowId, ${CELL_ID}`),
+            getCellContentDoc(tableId, cellId, 3),
+          );
+        },
+      );
+    },
+  );
   addMethod(
     'getJson',
-    '',
+    EMPTY_STRING,
     'Json',
     storeMethod('getJson'),
-    `Gets a a string serialization ${THE_CONTENT_OF_THE_STORE}`,
+    `${verbs[0]} a string serialization ${THE_CONTENT_OF_THE_STORE}`,
   );
   addMethod(
     'setJson',
     'json: Json',
     storeType,
     fluentStoreMethod('setJson', 'json'),
-    `Sets ${THE_CONTENT_OF_THE_STORE} from a serialized string`,
+    `${verbs[1]} ${THE_CONTENT_OF_THE_STORE} from a serialized string`,
   );
   addMethod(
     'transaction',
@@ -677,7 +713,7 @@ const getStoreApi = (schema, module) => {
   );
   addMethod(
     'startTransaction',
-    '',
+    EMPTY_STRING,
     storeType,
     fluentStoreMethod('startTransaction'),
     'Explicitly starts a transaction',
@@ -691,42 +727,42 @@ const getStoreApi = (schema, module) => {
   );
   addMethod(
     'addTablesListener',
-    `listener: ${tablesListenerType}, mutator?: boolean`,
+    `${LISTENER}: ${tablesListenerType}, mutator?: boolean`,
     'Id',
-    storeListener('addTablesListener', '', 'mutator'),
+    storeListener('addTablesListener', EMPTY_STRING, 'mutator'),
     `${REGISTERS_A_LISTENER} whenever ${THE_CONTENT_OF_THE_STORE} changes`,
   );
   addMethod(
     'addTableIdsListener',
-    `listener: ${tableIdsListenerType}, mutator?: boolean`,
+    `${LISTENER}: ${tableIdsListenerType}, mutator?: boolean`,
     'Id',
-    storeListener('addTableIdsListener', '', 'mutator'),
+    storeListener('addTableIdsListener', EMPTY_STRING, 'mutator'),
     getListenerDoc('the Table Ids', THE_STORE, 1),
   );
   addMethod(
     'addTableListener',
-    `tableId: ${tableIdType} | null, listener: ${tableListenerType}, mutator?: boolean`,
+    `tableId: ${tableIdType} | null, ${LISTENER}: ${tableListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addTableListener', 'tableId', 'mutator'),
     getListenerDoc('a Table', THE_STORE),
   );
   addMethod(
     'addRowIdsListener',
-    `tableId: ${tableIdType} | null, listener: ${rowIdsListenerType}, mutator?: boolean`,
+    `tableId: ${tableIdType} | null, ${LISTENER}: ${rowIdsListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addRowIdsListener', 'tableId', 'mutator'),
     getListenerDoc('the Row Ids', 'a Table', 1),
   );
   addMethod(
     'addRowListener',
-    `tableId: ${tableIdType} | null, rowId: IdOrNull, listener: ${rowListenerType}, mutator?: boolean`,
+    `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${rowListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addRowListener', 'tableId, rowId', 'mutator'),
     getListenerDoc('a Row', 'a Table'),
   );
   addMethod(
     'addCellIdsListener',
-    `tableId: ${tableIdType} | null, rowId: IdOrNull, listener: ${cellIdsListenerType}, mutator?: boolean`,
+    `tableId: ${tableIdType} | null, rowId: IdOrNull, ${LISTENER}: ${cellIdsListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addCellIdsListener', 'tableId, rowId', 'mutator'),
     getListenerDoc('the Cell Ids', 'a Row', 1),
@@ -734,113 +770,133 @@ const getStoreApi = (schema, module) => {
   addMethod(
     'addCellListener',
     `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${join(
-      allCellIdType,
+      mapTableSchema((_, tableTypes2) => tableTypes2[3]),
       ' | ',
-    )} | null, listener: ${cellListenerType}, mutator?: boolean`,
+    )} | null, ${LISTENER}: ${cellListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
     getListenerDoc('a Cell', 'a Row'),
   );
   addMethod(
     'addInvalidCellListener',
-    `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull, listener: ${invalidCellListenerType}, mutator?: boolean`,
+    `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull, ${LISTENER}: ${invalidCellListenerType}, mutator?: boolean`,
     'Id',
     storeListener('addCellListener', 'tableId, rowId, cellId', 'mutator'),
     `${REGISTERS_A_LISTENER} whenever an invalid Cell change was attempted`,
   );
   addMethod(
     'addWillFinishTransactionListener',
-    `listener: ${transactionListenerType}`,
+    `${LISTENER}: ${transactionListenerType}`,
     'Id',
     storeListener('addWillFinishTransactionListener'),
-    `${REGISTERS_A_LISTENER} just before the end of the transaction`,
+    `${REGISTERS_A_LISTENER} just before ${THE_END_OF_THE_TRANSACTION}`,
   );
   addMethod(
     'addDidFinishTransactionListener',
-    `listener: ${transactionListenerType}`,
+    `${LISTENER}: ${transactionListenerType}`,
     'Id',
     storeListener('addDidFinishTransactionListener'),
-    `${REGISTERS_A_LISTENER} just after the end of the transaction`,
+    `${REGISTERS_A_LISTENER} just after ${THE_END_OF_THE_TRANSACTION}`,
   );
   addMethod(
     'callListener',
-    'listenerId: Id',
+    `${LISTENER}Id: Id`,
     storeType,
-    fluentStoreMethod('callListener', 'listenerId'),
-    'Manually provoke a listener to be called',
+    fluentStoreMethod('callListener', `${LISTENER}Id`),
+    `Manually provoke a ${LISTENER} to be called`,
   );
   addMethod(
     'delListener',
-    'listenerId: Id',
+    `${LISTENER}Id: Id`,
     storeType,
-    fluentStoreMethod('delListener', 'listenerId'),
-    `Remove a listener that was previously added to ${THE_STORE}`,
+    fluentStoreMethod('delListener', `${LISTENER}Id`),
+    `Remove a ${LISTENER} that was previously added to ${THE_STORE}`,
   );
   addMethod(
     'getStore',
-    '',
+    EMPTY_STRING,
     'Store',
     'store',
-    'Gets the underlying Store object',
-  );
-  updateType(
-    tablesType,
-    `{${join(tablesTypes, ' ')}}`,
-    `${REPRESENTS} ${THE_CONTENT_OF_THE_STORE}`,
-  );
-  updateType(
-    tableIdType,
-    join(tableIdTypes, ' | '),
-    `A Table Id in ${THE_STORE}`,
-  );
-  updateType(
-    tableCallbackType,
-    `(...[tableId, rowCallback]: ${join(
-      tableCallbackArgTypes,
-      ' | ',
-    )}) => void`,
-    getCallbackDoc('a Table Id, and a Row iterator'),
-  );
-  updateType(
-    getCellChangeType,
-    `(...[tableId, rowId, cellId]: ${join(
-      getCellChangeArgTypes,
-      ' | ',
-    )}) => CellChange`,
-    `A function that returns information about any Cell's changes during a transaction`,
-  );
-  updateType(
-    cellListenerType,
-    `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${join(
-      cellListenerArgTypes,
-      ' | ',
-    )}) => void`,
-    `A function for listening to changes to a Cell in ${THE_STORE}`,
+    `${verbs[0]} the underlying Store object`,
   );
   mapForEach(mapCellTypes, (type, mapCellType) =>
     addType(
       mapCellType,
-      `(cell: ${type} | undefined) => ${type}`,
+      `(cell: ${type}${OR_UNDEFINED}) => ${type}`,
       `Takes a ${type} Cell value and returns another`,
     ),
   );
-  addImport(1, `./${moduleName}.d`, ...collValues(mapCellTypes));
-  addConstant('store', ['createStore().setSchema({', ...schemaLines, '})']);
+  addImport(0, 'tinybase', 'CellChange', ...COMMON_IMPORTS);
+  addImport(1, 'tinybase', 'createStore', ...COMMON_IMPORTS);
+  addImport(
+    1,
+    moduleDefinition,
+    storeType,
+    `create${storeType} as create${storeType}Decl`,
+    tablesType,
+    tableIdType,
+    tableCallbackType,
+    tablesListenerType,
+    tableIdsListenerType,
+    tableListenerType,
+    rowIdsListenerType,
+    rowListenerType,
+    cellIdsListenerType,
+    cellListenerType,
+    invalidCellListenerType,
+    transactionListenerType,
+    ...collValues(mapCellTypes),
+  );
+  addConstant('store', [
+    'createStore().setSchema({',
+    flat(
+      mapTableSchema((tableId, _, __, TABLE_ID) => [
+        `[${TABLE_ID}]: {`,
+        ...mapCellSchema(
+          tableId,
+          (_2, type, defaultValue, CELL_ID) =>
+            `[${CELL_ID}]: {[${addConstant(
+              snake(TYPE),
+              `'${TYPE}'`,
+            )}]: ${addConstant(snake(type), `'${type}'`)}${
+              isUndefined(defaultValue)
+                ? EMPTY_STRING
+                : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ${
+                    isString(defaultValue)
+                      ? addConstant(snake(defaultValue), `'${defaultValue}'`)
+                      : defaultValue
+                  }`
+            }},`,
+        ),
+        `},`,
+      ]),
+    ),
+    '})',
+  ]);
+  addFunction('fluent', 'actions: () => Store', [
+    'actions();',
+    `return ${storeInstance};`,
+  ]);
+  addFunction(
+    'proxy',
+    `${LISTENER}: any`,
+    `(_: Store, ...args: any[]) => ${LISTENER}(${storeInstance}, ...args)`,
+  );
   addConstant(storeInstance, ['{', ...getMethods(1), '}']);
   return [
     build(
       ...getImports(0),
       ...getTypes(),
-      `export interface ${storeType} {`,
+      `${EXPORT} interface ${storeType} {`,
       ...getMethods(0),
       `}`,
-      '',
+      EMPTY_STRING,
       comment(`Creates a ${storeType} object`),
-      `export function create${storeType}(): ${storeType};`,
+      `${EXPORT} function create${storeType}(): ${storeType};`,
     ),
     build(
       ...getImports(1),
-      `export const create${storeType}: typeof create${storeType}Decl = () => {`,
+      `${EXPORT} const create${storeType}: typeof create${storeType}Decl = () => {`,
       ...getConstants(),
       `return Object.freeze(${storeInstance});`,
       `};`,
@@ -934,14 +990,15 @@ const createTools = getCreateFunction((store) => {
   };
   const getStoreApi$1 = (module) => getStoreApi(getStoreSchema(), module);
   const getPrettyStoreApi = async (module) => {
-    const files = getStoreApi$1(module);
+    let format;
     try {
-      const {format} = await import('prettier');
-      return arrayMap(files, (file) =>
-        formatJsDoc(format(file, prettierConfig)),
-      );
-    } catch {}
-    return files;
+      format = (await import('prettier')).format;
+    } catch {
+      format = (str) => str;
+    }
+    return arrayMap(getStoreApi$1(module), (file) =>
+      formatJsDoc(format(file, prettierConfig)),
+    );
   };
   const tools = {
     getStoreStats,