rads-db 0.1.102 → 0.1.104

package/drivers/indexedDb.cjs

@@ -4,500 +4,216 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 module.exports = void 0;
-var _cosmos = require("@azure/cosmos");
+var _dexie = _interopRequireDefault(require("dexie"));
 var _lodash = _interopRequireDefault(require("lodash"));
+var _memory = require("./memory.cjs");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const cosmosClientCache = {};
-const databaseClientCache = {};
-const containerClientCache = {};
-const simpleSubclauseRegex = /^[a-z0-9_@]+.[a-z0-9_@]+ = [a-z0-9_@.]+$/i;
-var _default = options => (schema, entity) => {
-  const client = getCosmosContainerClient(options);
-  async function getItemByIds(ids, ctx) {
-    const {
-      query,
-      parameters
-    } = getCosmosQuery(schema, entity, {
-      where: {
-        id_in: ids
-      }
-    });
-    const response = client.items.query({
-      query,
-      parameters: Object.keys(parameters).map(k => ({
-        name: `@${k}`,
-        value: parameters[k]
-      }))
-    });
-    const r = await response.fetchAll();
-    ctx?.log?.({
-      charge: r.requestCharge,
-      request: query
-    });
-    return r.resources;
-  }
-  async function getMany(args, ctx) {
-    args = args || {};
-    const where = args.where || {};
-    const whereKeys = _lodash.default.keys(where);
-    if (whereKeys.length === 1) {
-      if (whereKeys[0] === "id" && where.id != null) {
-        const items = await getItemByIds([where.id], ctx);
-        return {
-          nodes: [items[0]].filter(x => x),
-          cursor: null
-        };
-      }
-      if (whereKeys[0] === "id_in" && where.id_in != null) {
-        const items = await getItemByIds(where.id_in, ctx);
-        return {
-          nodes: items.filter(x => x),
-          cursor: null
-        };
-      }
-    }
-    const {
-      query,
-      parameters
-    } = getCosmosQuery(schema, entity, args);
-    const response = client.items.query({
-      query,
-      parameters: Object.keys(parameters).map(k => ({
-        name: `@${k}`,
-        value: parameters[k]
-      }))
-    }, {
-      continuationToken: args.cursor || void 0,
-      continuationTokenLimitInKB: 4,
-      maxItemCount: args.maxItemCount
-    });
-    const page = await response.fetchNext();
-    ctx?.log?.({
-      charge: page.requestCharge,
-      request: query
-    });
+const dbs = {};
+const tableOperatorFns = {
+  eq: (where, value) => where.equals(value),
+  ieq: (where, value) => where.equalsIgnoreCase(value),
+  in: (where, value) => where.anyOf(value),
+  startsWith: (where, value) => where.startsWith(value),
+  istartsWith: (where, value) => where.startsWithIgnoreCase(value),
+  gt: (where, value) => where.above(value),
+  lt: (where, value) => where.below(value)
+};
+const tableOperatorNotFns = {
+  eq: (where, value) => where.notEqual(value),
+  in: (where, value) => where.noneOf(value),
+  gt: (where, value) => where.belowOrEqual(value),
+  lt: (where, value) => where.aboveOrEqual(value)
+};
+var _default = options => {
+  const dbName = options?.dbName || "db";
+  const dbWrapper = getDb(options);
+  return (schema, entity) => {
+    const handle = schema[entity]?.handle;
+    if (!handle) throw new Error(`Entity ${entity} not found`);
+    dbWrapper.entities[handle] = true;
     return {
-      nodes: page.resources,
-      cursor: page.continuationToken || null
-    };
-  }
-  const instance = {
-    driverName: "azureCosmos",
-    getMany,
-    async clear(ctx) {
-      let currentCursor = null;
-      do {
-        const {
-          nodes,
-          cursor
-        } = await getMany({
-          cursor: currentCursor
-        });
-        for (const r of nodes) {
-          const resp = await client.item(r.id, r._partition).delete();
-          ctx?.log?.({
-            charge: resp.requestCharge,
-            request: `delete#${r._partition}|${r.id}`
-          });
+      driverName: "indexedDb",
+      async getMany(args, ctx) {
+        await initDbIfNeeded(dbName);
+        const normalizedArgs = normalizeArgs(args);
+        const dexieResult = applyArgsToDexieTable(dbWrapper.db.table(handle), normalizedArgs);
+        let resultCursor;
+        const newCursor = normalizedArgs.cursor + dexieResult.maxItemCount;
+        let result = await dexieResult.collection.toArray();
+        if (dexieResult.orderByProp) {
+          result = _lodash.default.orderBy(result, [dexieResult.orderByProp], [dexieResult.orderByDirection.toLowerCase()]);
+          if (dexieResult.maxItemCount) {
+            if (result.length > newCursor) {
+              resultCursor = newCursor;
+            }
+            result = result.slice(normalizedArgs.cursor, newCursor);
+          }
+          return {
+            nodes: result,
+            cursor: resultCursor ? _lodash.default.toString(resultCursor) : null
+          };
         }
-        currentCursor = cursor;
-      } while (currentCursor);
-    },
-    async putMany(items, ctx) {
-      for (const item of items) {
-        const id = item?.id;
-        if (!id) throw new Error(`You must provide an id`);
-        const itemToPut = {
-          _partition: entity,
-          id,
-          ...item
+        if (dexieResult.maxItemCount && result.length >= dexieResult.maxItemCount) {
+          resultCursor = newCursor;
+        }
+        return {
+          nodes: result,
+          cursor: resultCursor ? _lodash.default.toString(resultCursor) : null
         };
-        const response = await client.items.upsert(itemToPut);
-        ctx?.log?.({
-          charge: response.requestCharge,
-          request: `put#${itemToPut._partition}|${itemToPut.id}`
-        });
+      },
+      async putMany(items, ctx) {
+        await initDbIfNeeded(dbName);
+        const table = dbWrapper.db.table(handle);
+        await table.bulkPut(items);
       }
-    }
+    };
   };
-  return instance;
 };
 module.exports = _default;
-function getCosmosQuery(schema, entity, args) {
-  args = args || {};
-  const where = args.where || {};
-  const parameters = {};
-  const whereClauses = [`r._partition = '${entity}'`, getCosmosQueryWhere({
-    schema,
-    entity
-  }, parameters, where)].filter(x => x);
-  let orderByClause = "";
-  if (args.orderBy) {
-    const orderByParts = args.orderBy.split("_");
-    const orderPropFromOrderBy = orderByParts.slice(0, -1).join(".");
-    const orderDirection = orderByParts.at(-1);
-    const orderProp = orderPropFromOrderBy === "value" ? `r["value"]` : `r.${orderPropFromOrderBy}`;
-    orderByClause = `order by ${orderProp} ${orderDirection}`;
+function applyArgsToDexieTable(table, args) {
+  const {
+    where,
+    orderByProperty,
+    orderByDirection,
+    maxItemCount
+  } = args;
+  let orderByProp = orderByProperty;
+  const indexedProps = ["id", ...table.schema.indexes.map(idx => idx.name)];
+  let collection;
+  for (const ip of indexedProps) {
+    collection = applyTableFiltering(table, where, ip);
+    if (collection) {
+      break;
+    }
+  }
+  if (!collection && orderByProp) {
+    if (indexedProps.includes(orderByProp)) {
+      collection = table.orderBy(orderByProp);
+      if (orderByDirection === "desc") collection = collection.reverse();
+      orderByProp = "";
+    }
+  }
+  if (!collection) {
+    collection = table.toCollection();
+  }
+  const f = (0, _memory.getFilter)(where);
+  if (f) {
+    collection = collection.filter(f);
+  }
+  if (maxItemCount && !orderByProp) {
+    if (args.cursor) collection = collection.offset(_lodash.default.toNumber(args.cursor));
+    collection = collection.limit(maxItemCount);
   }
-  const query = `select * from r where ${whereClauses.join(" AND ")} ${orderByClause}`;
   return {
-    query,
-    parameters
+    collection,
+    orderByProp,
+    orderByDirection,
+    maxItemCount
   };
 }
-const operatorHandlers = {
-  some: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramNamePrefix,
-      paramName,
-      whereVal
-    } = whereArgs;
-    const newCtx = {
-      ...ctx,
-      entity: ctx.schema[ctx.entity].fields[ctx.field].type
-    };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${name}.`, `${paramNamePrefix}${paramName}_`);
-    if (subClause) {
-      if (simpleSubclauseRegex.test(subClause)) {
-        const parts = subClause.split(" ");
-        const field = parts[0];
-        const variable = parts[2];
-        return `array_contains(${namePrefix}${name}, { ${field.split(".")[1]}: ${variable} }, true)`;
-      }
-      return `exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
-    }
-    return `array_length(${namePrefix}${name}) > 0`;
-  },
-  none: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramNamePrefix,
-      paramName,
-      whereVal
-    } = whereArgs;
-    const newCtx = {
-      ...ctx,
-      entity: ctx.schema[ctx.entity].fields[ctx.field].type
-    };
-    const subClause = getCosmosQueryWhere(newCtx, parameters, whereVal, `${name}.`, `${paramNamePrefix}${paramName}_`);
-    if (subClause) return `not exists (select ${name} from ${name} in ${namePrefix}${name} where ${subClause})`;
-    return `array_length(${namePrefix}${name}) = 0`;
-  },
-  and: (ctx, parameters, whereArgs) => {
-    const {
-      namePrefix,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._and must be an array`);
-    const clauses = [];
-    for (let i = 0; i < whereVal.length; i++) {
-      const andQuery = getCosmosQueryWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}and${i}_`);
-      clauses.push(andQuery);
-    }
-    if (!clauses.length) return null;
-    return `((${clauses.join(") and (")}))`;
-  },
-  not: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const subClause = getCosmosQueryWhere(ctx, parameters, whereVal, `${namePrefix}${name}`, `${paramNamePrefix}not_`);
-    if (!subClause) return null;
-    return `not(${subClause})`;
-  },
-  or: (ctx, parameters, whereArgs) => {
-    const {
-      namePrefix,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    if (!_lodash.default.isArray(whereVal)) throw new Error(`Value for where._or must be an array`);
-    const clauses = [];
-    for (let i = 0; i < whereVal.length; i++) {
-      const orQuery = getCosmosQueryWhere(ctx, parameters, whereVal[i], namePrefix, `${paramNamePrefix}or${i}_`);
-      clauses.push(orQuery);
-    }
-    if (!clauses.length) return null;
-    return `((${clauses.join(") or (")}))`;
-  },
-  isNull: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      whereVal
-    } = whereArgs;
-    const n = `${namePrefix}${name}`;
-    if (whereVal) return `(not (is_defined(${n})) or ${n} = null)`;
-    return `(is_defined(${n}) and ${n} != null)`;
-  },
-  eq: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} = @${pn}`;
-  },
-  in: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `array_contains(@${pn}, ${namePrefix}${name})`;
-  },
-  startsWith: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn})`;
-  },
-  istartsWith: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `startswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  endsWith: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn})`;
-  },
-  iendsWith: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `endswith(${namePrefix}${name}, @${pn}, true)`;
-  },
-  contains: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const fieldType = ctx.schema[ctx.entity].fields[ctx.field];
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    if (fieldType.isArray) {
-      return `array_contains(${namePrefix}${name}, @${pn})`;
-    }
-    return `contains(${namePrefix}${name}, @${pn})`;
-  },
-  icontains: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `contains(${namePrefix}${name}, @${pn}, true)`;
-  },
-  ieq: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `stringequals(${namePrefix}${name}, @${pn}, true)`;
-  },
-  gt: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} > @${pn}`;
-  },
-  gte: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} >= @${pn}`;
-  },
-  lt: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} < @${pn}`;
-  },
-  lte: (ctx, parameters, whereArgs) => {
-    const {
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix,
-      whereVal
-    } = whereArgs;
-    const pn = `${paramNamePrefix}${paramName}`;
-    parameters[pn] = whereVal;
-    return `${namePrefix}${name} <= @${pn}`;
+function applyTableFiltering(table, where, fieldName) {
+  if (["isArchived", "_type"].includes(fieldName)) {
+    return void 0;
   }
-};
-function getCosmosQueryWhere(ctx, parameters, where, namePrefix = "r.", paramNamePrefix = "") {
-  const whereClauses = [];
-  for (const key in where) {
-    const [nameFromWhere, operator] = getWhereNameOperatorPair(key);
-    let name = nameFromWhere;
-    if (name === "value") {
-      name = `["${name}"]`;
-      namePrefix = namePrefix.slice(0, -1);
+  for (const operatorKey in tableOperatorFns) {
+    const operator = operatorKey === "eq" ? null : operatorKey;
+    const whereKey = [fieldName, operator].filter(x => x).join("_");
+    const whereVal = _lodash.default.get(where, whereKey);
+    if (whereVal != null) {
+      const whereClause = table.where(fieldName);
+      _lodash.default.set(where, whereKey, void 0);
+      return tableOperatorFns[operatorKey](whereClause, whereVal);
     }
-    const paramName = key;
-    const whereVal = where[key];
-    if (whereVal == null) continue;
-    const f = getCosmosQueryWhereInner({
-      ...ctx,
-      field: nameFromWhere
-    }, parameters, {
-      operator,
-      whereVal,
-      name,
-      namePrefix,
-      paramName,
-      paramNamePrefix
-    });
-    if (f) whereClauses.push(f);
   }
-  return whereClauses.join(" AND ");
-}
-function getCosmosQueryWhereInner(ctx, parameters, whereArgs) {
-  const {
-    operator,
-    whereVal,
-    name,
-    namePrefix,
-    paramName,
-    paramNamePrefix
-  } = whereArgs;
-  if (!operator && _lodash.default.isObject(whereVal)) {
-    return getCosmosQueryWhere(ctx, parameters, whereVal, `${namePrefix}${name}.`, `${paramNamePrefix}${paramName}_`);
+  for (const operatorKey in tableOperatorNotFns) {
+    const operator = operatorKey === "eq" ? null : operatorKey;
+    const whereKey = [fieldName, operator].filter(x => x).join("_");
+    const whereKeyNot = `_not.${whereKey}`;
+    const whereValNot = _lodash.default.get(where, whereKeyNot);
+    if (whereValNot != null) {
+      const whereClause = table.where(fieldName);
+      _lodash.default.set(where, whereKeyNot, void 0);
+      return tableOperatorNotFns[operatorKey](whereClause, whereValNot);
+    }
   }
-  const fn = operatorHandlers[operator || "eq"];
-  if (!fn) console.warn(`Unsupported operator: "${operator}"`);
-  return fn(ctx, parameters, whereArgs);
 }
-function getCosmosContainerClient(options) {
-  options = {
-    databaseName: "main",
-    containerName: "main",
-    ...options
+function normalizeArgs(args) {
+  if (!args) args = {};
+  const where = _lodash.default.cloneDeep(args.where) || {};
+  let orderBy = args.orderBy || "";
+  if (_lodash.default.isArray(orderBy)) orderBy = orderBy[0] || "";
+  const orderByParts = orderBy.split("_");
+  const orderByProperty = orderByParts.slice(0, -1).join(".");
+  const orderByDirection = orderByParts.slice(-1)[0];
+  const maxItemCount = args.maxItemCount || 100;
+  return {
+    where,
+    orderByProperty,
+    orderByDirection,
+    maxItemCount,
+    cursor: args.cursor ? _lodash.default.toNumber(args.cursor) : 0
   };
-  const {
-    databaseName,
-    containerName,
-    endpoint
-  } = options;
-  const key = `${endpoint}|${databaseName}|${containerName}`;
-  if (!containerClientCache[key]) {
-    containerClientCache[key] = getCosmosDatabaseClient(options).container(containerName);
-  }
-  return containerClientCache[key];
 }
-function getCosmosDatabaseClient(options) {
-  options = {
-    databaseName: "main",
-    containerName: "main",
-    ...options
-  };
-  const {
-    databaseName,
-    endpoint
-  } = options;
-  const key = `${endpoint}|${databaseName}`;
-  if (!databaseClientCache[key]) {
-    databaseClientCache[key] = getCosmosAccountClient(options).database(databaseName);
+async function initDbIfNeeded(dbName) {
+  const dbWrapper = dbs[dbName];
+  if (!dbWrapper.initPromise) {
+    dbWrapper.initPromise = initDbInner(dbName);
   }
-  return databaseClientCache[key];
+  return dbWrapper.initPromise;
 }
-function getCosmosAccountClient(options) {
-  options = {
-    databaseName: "main",
-    containerName: "main",
-    ...options
+async function initDbInner(dbName) {
+  const dbWrapper = dbs[dbName];
+  const stores = {
+    _system: "id"
   };
-  const {
-    endpoint,
-    accountKey
-  } = options;
-  const key = endpoint;
-  if (!cosmosClientCache[key]) {
-    cosmosClientCache[key] = new _cosmos.CosmosClient({
-      endpoint,
-      key: accountKey,
-      ...options.options
+  for (const entity in dbWrapper.entities) {
+    stores[entity] = "id";
+  }
+  let db = new _dexie.default(dbWrapper.driverOptions.dbName, dbWrapper.driverOptions.dexieOptions);
+  db.version(1).stores(stores);
+  let systemTable = db._system;
+  const invalidateCounter = dbWrapper.driverOptions.invalidateCounter;
+  const currentVersionObject = await systemTable.get("_versionObject");
+  if (!currentVersionObject) {
+    await systemTable.put({
+      id: "_versionObject",
+      stores,
+      version: 1,
+      invalidateCounter
+    });
+  } else if (!_lodash.default.isEqual(currentVersionObject.invalidateCounter, invalidateCounter)) {
+    await db.delete();
+    db = new _dexie.default(dbWrapper.driverOptions.dbName, dbWrapper.driverOptions.dexieOptions);
+    db.version(1).stores(stores);
+    systemTable = db._system;
+    await systemTable.put({
+      id: "_versionObject",
+      stores,
+      version: 1,
+      invalidateCounter
+    });
+  } else if (!_lodash.default.isEqual(currentVersionObject.stores, stores)) {
+    const newVersion = currentVersionObject.version + 1;
+    db.version(newVersion).stores(stores);
+    await systemTable.put({
+      id: "_versionObject",
+      stores,
+      version: newVersion
     });
   }
-  return cosmosClientCache[key];
+  dbWrapper.db = db;
 }
-function getWhereNameOperatorPair(whereKey) {
-  if (whereKey.startsWith("_type")) {
-    const operator = whereKey.split("_")[2];
-    return ["_type", operator];
-  }
-  return whereKey.split("_");
+function getDb(options) {
+  const dbName = options?.dbName || "db";
+  if (dbs[dbName]?.db) dbs[dbName].db?.close();
+  dbs[dbName] = {
+    entities: {},
+    driverOptions: {
+      dbName,
+      dexieOptions: {},
+      invalidateCounter: 0,
+      ...options
+    }
+  };
+  return dbs[dbName];
 }