@graffiti-garden/implementation-local 0.6.3 → 1.0.0

package/dist/esm/database.js

@@ -1,603 +0,0 @@
-import {
-  GraffitiErrorNotFound,
-  GraffitiErrorSchemaMismatch,
-  GraffitiErrorForbidden,
-  GraffitiErrorPatchError
-} from "@graffiti-garden/api";
-import {
-  randomBase64,
-  applyGraffitiPatch,
-  maskGraffitiObject,
-  isActorAllowedGraffitiObject,
-  compileGraffitiObjectSchema,
-  unpackObjectUrl
-} from "./utilities.js";
-const DEFAULT_ORIGIN = "graffiti:local:";
-const LAST_MODIFIED_BUFFER = 6e4;
-class GraffitiLocalDatabase {
-  db_;
-  applyPatch_;
-  ajv_;
-  options;
-  origin;
-  get db() {
-    if (!this.db_) {
-      this.db_ = (async () => {
-        const { default: PouchDB } = await import("pouchdb");
-        const pouchDbOptions = {
-          name: "graffitiDb",
-          ...this.options.pouchDBOptions
-        };
-        const db = new PouchDB(
-          pouchDbOptions.name,
-          pouchDbOptions
-        );
-        await db.put({
-          _id: "_design/indexes",
-          views: {
-            objectsPerChannelAndLastModified: {
-              map: function(object) {
-                const paddedLastModified = object.lastModified.toString().padStart(15, "0");
-                object.channels.forEach(function(channel) {
-                  const id = encodeURIComponent(channel) + "/" + paddedLastModified;
-                  emit(id);
-                });
-              }.toString()
-            },
-            orphansPerActorAndLastModified: {
-              map: function(object) {
-                if (object.channels.length === 0) {
-                  const paddedLastModified = object.lastModified.toString().padStart(15, "0");
-                  const id = encodeURIComponent(object.actor) + "/" + paddedLastModified;
-                  emit(id);
-                }
-              }.toString()
-            },
-            channelStatsPerActor: {
-              map: function(object) {
-                if (object.tombstone) return;
-                object.channels.forEach(function(channel) {
-                  const id = encodeURIComponent(object.actor) + "/" + encodeURIComponent(channel);
-                  emit(id, object.lastModified);
-                });
-              }.toString(),
-              reduce: "_stats"
-            }
-          }
-        }).catch((error) => {
-          if (error && typeof error === "object" && "name" in error && error.name === "conflict") {
-            return;
-          } else {
-            throw error;
-          }
-        });
-        return db;
-      })();
-    }
-    return this.db_;
-  }
-  get applyPatch() {
-    if (!this.applyPatch_) {
-      this.applyPatch_ = (async () => {
-        const imported = await import("fast-json-patch");
-        return imported.applyPatch || imported.default.applyPatch;
-      })();
-    }
-    return this.applyPatch_;
-  }
-  get ajv() {
-    if (!this.ajv_) {
-      this.ajv_ = this.options.ajv ? Promise.resolve(this.options.ajv) : (async () => {
-        const { default: Ajv } = await import("ajv");
-        return new Ajv({ strict: false });
-      })();
-    }
-    return this.ajv_;
-  }
-  extractGraffitiObject(object) {
-    const { value, channels, allowed, url, actor, lastModified } = object;
-    return {
-      value,
-      channels,
-      allowed,
-      url,
-      actor,
-      lastModified
-    };
-  }
-  constructor(options) {
-    this.options = options ?? {};
-    this.origin = this.options.origin ?? DEFAULT_ORIGIN;
-    if (!this.origin.endsWith(":") && !this.origin.endsWith("/")) {
-      this.origin += "/";
-    }
-  }
-  async allDocsAtLocation(objectUrl) {
-    const url = unpackObjectUrl(objectUrl) + "/";
-    const results = await (await this.db).allDocs({
-      startkey: url,
-      endkey: url + "\uFFFF",
-      // \uffff is the last unicode character
-      include_docs: true
-    });
-    const docs = results.rows.map((row) => row.doc).reduce((acc, doc) => {
-      if (doc) acc.push(doc);
-      return acc;
-    }, []);
-    return docs;
-  }
-  docId(objectUrl) {
-    return objectUrl.url + "/" + randomBase64();
-  }
-  get = async (...args) => {
-    const [urlObject, schema, session] = args;
-    const docsAll = await this.allDocsAtLocation(urlObject);
-    const docs = docsAll.filter(
-      (doc2) => isActorAllowedGraffitiObject(doc2, session)
-    );
-    if (!docs.length)
-      throw new GraffitiErrorNotFound(
-        "The object you are trying to get either does not exist or you are not allowed to see it"
-      );
-    const doc = docs.reduce(
-      (a, b) => a.lastModified > b.lastModified || a.lastModified === b.lastModified && !a.tombstone && b.tombstone ? a : b
-    );
-    if (doc.tombstone) {
-      throw new GraffitiErrorNotFound(
-        "The object you are trying to get either does not exist or you are not allowed to see it"
-      );
-    }
-    const object = this.extractGraffitiObject(doc);
-    maskGraffitiObject(object, [], session);
-    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
-    if (!validate(object)) {
-      throw new GraffitiErrorSchemaMismatch();
-    }
-    return object;
-  };
-  /**
-   * Deletes all docs at a particular location.
-   * If the `keepLatest` flag is set to true,
-   * the doc with the most recent timestamp will be
-   * spared. If there are multiple docs with the same
-   * timestamp, the one with the highest `_id` will be
-   * spared.
-   */
-  async deleteAtLocation(url, options = {
-    keepLatest: false
-  }) {
-    const docsAtLocationAll = await this.allDocsAtLocation(url);
-    const docsAtLocationAllowed = options.session ? docsAtLocationAll.filter(
-      (doc) => isActorAllowedGraffitiObject(doc, options.session)
-    ) : docsAtLocationAll;
-    if (!docsAtLocationAllowed.length) {
-      throw new GraffitiErrorNotFound(
-        "The object you are trying to delete either does not exist or you are not allowed to see it"
-      );
-    } else if (options.session && docsAtLocationAllowed.some((doc) => doc.actor !== options.session?.actor)) {
-      throw new GraffitiErrorForbidden(
-        "You cannot delete an object owned by another actor"
-      );
-    }
-    const docsAtLocation = docsAtLocationAllowed.filter(
-      (doc) => !doc.tombstone
-    );
-    if (!docsAtLocation.length) return void 0;
-    const latestModified = docsAtLocation.map((doc) => doc.lastModified).reduce((a, b) => a > b ? a : b);
-    const docsToDelete = docsAtLocation.filter(
-      (doc) => !options.keepLatest || doc.lastModified < latestModified
-    );
-    const concurrentDocsAll = docsAtLocation.filter(
-      (doc) => options.keepLatest && doc.lastModified === latestModified
-    );
-    if (concurrentDocsAll.length) {
-      const keepDocId = concurrentDocsAll.map((doc) => doc._id).reduce((a, b) => a > b ? a : b);
-      const concurrentDocsToDelete = concurrentDocsAll.filter(
-        (doc) => doc._id !== keepDocId
-      );
-      docsToDelete.push(...concurrentDocsToDelete);
-    }
-    const lastModified = options.keepLatest ? latestModified : (/* @__PURE__ */ new Date()).getTime();
-    const deleteResults = await (await this.db).bulkDocs(
-      docsToDelete.map((doc) => ({
-        ...doc,
-        tombstone: true,
-        lastModified
-      }))
-    );
-    let deletedObject = void 0;
-    for (const resultOrError of deleteResults) {
-      if ("ok" in resultOrError) {
-        const { id } = resultOrError;
-        const deletedDoc = docsToDelete.find((doc) => doc._id === id);
-        if (deletedDoc) {
-          deletedObject = {
-            ...this.extractGraffitiObject(deletedDoc),
-            lastModified
-          };
-          break;
-        }
-      }
-    }
-    return deletedObject;
-  }
-  delete = async (...args) => {
-    const [url, session] = args;
-    const deletedObject = await this.deleteAtLocation(url, {
-      session
-    });
-    if (!deletedObject) {
-      throw new GraffitiErrorNotFound("The object has already been deleted");
-    }
-    return deletedObject;
-  };
-  put = async (...args) => {
-    const [objectPartial, session] = args;
-    if (objectPartial.actor && objectPartial.actor !== session.actor) {
-      throw new GraffitiErrorForbidden(
-        "Cannot put an object with a different actor than the session actor"
-      );
-    }
-    if (objectPartial.url) {
-      let oldObject;
-      try {
-        oldObject = await this.get(objectPartial.url, {}, session);
-      } catch (e) {
-        if (e instanceof GraffitiErrorNotFound) {
-          if (!this.options.allowSettingArbitraryUrls) {
-            throw new GraffitiErrorNotFound(
-              "The object you are trying to replace does not exist or you are not allowed to see it"
-            );
-          }
-        } else {
-          throw e;
-        }
-      }
-      if (oldObject?.actor !== session.actor) {
-        throw new GraffitiErrorForbidden(
-          "The object you are trying to replace is owned by another actor"
-        );
-      }
-    }
-    const lastModified = (this.options.allowSettinngLastModified ?? false) && objectPartial.lastModified || (/* @__PURE__ */ new Date()).getTime();
-    const object = {
-      value: objectPartial.value,
-      channels: objectPartial.channels,
-      allowed: objectPartial.allowed,
-      url: objectPartial.url ?? this.origin + randomBase64(),
-      actor: session.actor,
-      tombstone: false,
-      lastModified
-    };
-    await (await this.db).put({
-      _id: this.docId(object),
-      ...object
-    });
-    const previousObject = await this.deleteAtLocation(object, {
-      keepLatest: true
-    });
-    if (previousObject) {
-      return previousObject;
-    } else {
-      return {
-        ...object,
-        value: {},
-        channels: [],
-        allowed: [],
-        tombstone: true
-      };
-    }
-  };
-  patch = async (...args) => {
-    const [patch, url, session] = args;
-    let originalObject;
-    try {
-      originalObject = await this.get(url, {}, session);
-    } catch (e) {
-      if (e instanceof GraffitiErrorNotFound) {
-        throw new GraffitiErrorNotFound(
-          "The object you are trying to patch does not exist or you are not allowed to see it"
-        );
-      } else {
-        throw e;
-      }
-    }
-    if (originalObject.actor !== session.actor) {
-      throw new GraffitiErrorForbidden(
-        "The object you are trying to patch is owned by another actor"
-      );
-    }
-    const patchObject = { ...originalObject };
-    for (const prop of ["value", "channels", "allowed"]) {
-      applyGraffitiPatch(await this.applyPatch, prop, patch, patchObject);
-    }
-    if (typeof patchObject.value !== "object" || Array.isArray(patchObject.value) || !patchObject.value) {
-      throw new GraffitiErrorPatchError("value is no longer an object");
-    }
-    if (!Array.isArray(patchObject.channels) || !patchObject.channels.every((channel) => typeof channel === "string")) {
-      throw new GraffitiErrorPatchError(
-        "channels are no longer an array of strings"
-      );
-    }
-    if (patchObject.allowed && (!Array.isArray(patchObject.allowed) || !patchObject.allowed.every((allowed) => typeof allowed === "string"))) {
-      throw new GraffitiErrorPatchError(
-        "allowed list is not an array of strings"
-      );
-    }
-    patchObject.lastModified = (/* @__PURE__ */ new Date()).getTime();
-    await (await this.db).put({
-      ...patchObject,
-      tombstone: false,
-      _id: this.docId(patchObject)
-    });
-    await this.deleteAtLocation(patchObject, {
-      keepLatest: true
-    });
-    return {
-      ...originalObject,
-      lastModified: patchObject.lastModified
-    };
-  };
-  queryLastModifiedSuffixes(schema, lastModified) {
-    let startKeySuffix = "";
-    let endKeySuffix = "\uFFFF";
-    if (typeof schema === "object" && schema.properties?.lastModified && typeof schema.properties.lastModified === "object") {
-      const lastModifiedSchema = schema.properties.lastModified;
-      const minimum = lastModified && lastModifiedSchema.minimum ? Math.max(lastModified, lastModifiedSchema.minimum) : lastModified ?? lastModifiedSchema.minimum;
-      const exclusiveMinimum = lastModifiedSchema.exclusiveMinimum;
-      let intMinimum;
-      if (exclusiveMinimum !== void 0) {
-        intMinimum = Math.ceil(exclusiveMinimum);
-        intMinimum === exclusiveMinimum && intMinimum++;
-      } else if (minimum !== void 0) {
-        intMinimum = Math.ceil(minimum);
-      }
-      if (intMinimum !== void 0) {
-        startKeySuffix = intMinimum.toString().padStart(15, "0");
-      }
-      const maximum = lastModifiedSchema.maximum;
-      const exclusiveMaximum = lastModifiedSchema.exclusiveMaximum;
-      let intMaximum;
-      if (exclusiveMaximum !== void 0) {
-        intMaximum = Math.floor(exclusiveMaximum);
-        intMaximum === exclusiveMaximum && intMaximum--;
-      } else if (maximum !== void 0) {
-        intMaximum = Math.floor(maximum);
-      }
-      if (intMaximum !== void 0) {
-        endKeySuffix = intMaximum.toString().padStart(15, "0");
-      }
-    }
-    return {
-      startKeySuffix,
-      endKeySuffix
-    };
-  }
-  async *streamObjects(index, startkey, endkey, validate, session, ifModifiedSince, channels, processedIds) {
-    if (ifModifiedSince !== void 0) {
-      const continueBuffer = this.options.continueBuffer ?? 1e3;
-      const timeElapsedSinceContinue = Date.now() - ifModifiedSince;
-      if (timeElapsedSinceContinue < continueBuffer) {
-        await new Promise(
-          (resolve) => setTimeout(resolve, continueBuffer - timeElapsedSinceContinue)
-        );
-      }
-      ifModifiedSince -= LAST_MODIFIED_BUFFER;
-    }
-    const result = await (await this.db).query(index, {
-      startkey,
-      endkey,
-      include_docs: true
-    });
-    for (const row of result.rows) {
-      const doc = row.doc;
-      if (!doc) continue;
-      if (processedIds?.has(doc._id)) continue;
-      processedIds?.add(doc._id);
-      if (ifModifiedSince === void 0 && doc.tombstone) continue;
-      const object = this.extractGraffitiObject(doc);
-      if (channels) {
-        if (!isActorAllowedGraffitiObject(object, session)) continue;
-        maskGraffitiObject(object, channels, session);
-      }
-      if (!validate(object)) continue;
-      yield doc.tombstone ? {
-        tombstone: true,
-        object: {
-          url: object.url,
-          lastModified: object.lastModified
-        }
-      } : { object };
-    }
-  }
-  async *discoverMeta(args, ifModifiedSince) {
-    const [channels, schema, session] = args;
-    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
-    const { startKeySuffix, endKeySuffix } = this.queryLastModifiedSuffixes(
-      schema,
-      ifModifiedSince
-    );
-    const processedIds = /* @__PURE__ */ new Set();
-    const startTime = (/* @__PURE__ */ new Date()).getTime();
-    for (const channel of channels) {
-      const keyPrefix = encodeURIComponent(channel) + "/";
-      const startkey = keyPrefix + startKeySuffix;
-      const endkey = keyPrefix + endKeySuffix;
-      const iterator = this.streamObjects(
-        "indexes/objectsPerChannelAndLastModified",
-        startkey,
-        endkey,
-        validate,
-        session,
-        ifModifiedSince,
-        channels,
-        processedIds
-      );
-      for await (const result of iterator) yield result;
-    }
-    return startTime;
-  }
-  async *recoverOrphansMeta(args, ifModifiedSince) {
-    const [schema, session] = args;
-    const { startKeySuffix, endKeySuffix } = this.queryLastModifiedSuffixes(
-      schema,
-      ifModifiedSince
-    );
-    const keyPrefix = encodeURIComponent(session.actor) + "/";
-    const startkey = keyPrefix + startKeySuffix;
-    const endkey = keyPrefix + endKeySuffix;
-    const validate = compileGraffitiObjectSchema(await this.ajv, schema);
-    const startTime = (/* @__PURE__ */ new Date()).getTime();
-    const iterator = this.streamObjects(
-      "indexes/orphansPerActorAndLastModified",
-      startkey,
-      endkey,
-      validate,
-      session,
-      ifModifiedSince
-    );
-    for await (const result of iterator) yield result;
-    return startTime;
-  }
-  discoverCursor(args, ifModifiedSince) {
-    return "discover:" + JSON.stringify({
-      channels: args[0],
-      schema: args[1],
-      actor: args[2]?.actor,
-      ifModifiedSince
-    });
-  }
-  async *discoverContinue(args, ifModifiedSince) {
-    const iterator = this.discoverMeta(args, ifModifiedSince);
-    while (true) {
-      const result = await iterator.next();
-      if (result.done) {
-        const ifModifiedSince2 = result.value;
-        return {
-          continue: () => this.discoverContinue(args, ifModifiedSince2),
-          cursor: this.discoverCursor(args, ifModifiedSince2)
-        };
-      }
-      yield result.value;
-    }
-  }
-  discover = (...args) => {
-    const iterator = this.discoverMeta(args);
-    const this_ = this;
-    return async function* () {
-      while (true) {
-        const result = await iterator.next();
-        if (result.done) {
-          return {
-            continue: () => this_.discoverContinue(args, result.value),
-            cursor: this_.discoverCursor(args, result.value)
-          };
-        }
-        if (result.value.tombstone) continue;
-        yield result.value;
-      }
-    }();
-  };
-  recoverOrphansCursor(args, ifModifiedSince) {
-    return "orphans:" + JSON.stringify({
-      schema: args[0],
-      actor: args[1]?.actor,
-      ifModifiedSince
-    });
-  }
-  async *recoverOrphansContinue(args, ifModifiedSince) {
-    const iterator = this.recoverOrphansMeta(args, ifModifiedSince);
-    while (true) {
-      const result = await iterator.next();
-      if (result.done) {
-        const ifModifiedSince2 = result.value;
-        return {
-          continue: () => this.recoverOrphansContinue(args, ifModifiedSince2),
-          cursor: this.recoverOrphansCursor(args, ifModifiedSince2)
-        };
-      }
-      yield result.value;
-    }
-  }
-  recoverOrphans = (...args) => {
-    const iterator = this.recoverOrphansMeta(args);
-    const this_ = this;
-    return async function* () {
-      while (true) {
-        const result = await iterator.next();
-        if (result.done) {
-          return {
-            continue: () => this_.recoverOrphansContinue(
-              args,
-              result.value
-            ),
-            cursor: this_.recoverOrphansCursor(args, result.value)
-          };
-        }
-        if (result.value.tombstone) continue;
-        yield result.value;
-      }
-    }();
-  };
-  channelStats = (session) => {
-    const this_ = this;
-    return async function* () {
-      const keyPrefix = encodeURIComponent(session.actor) + "/";
-      const result = await (await this_.db).query("indexes/channelStatsPerActor", {
-        startkey: keyPrefix,
-        endkey: keyPrefix + "\uFFFF",
-        reduce: true,
-        group: true
-      });
-      for (const row of result.rows) {
-        const channelEncoded = row.key.split("/")[1];
-        if (typeof channelEncoded !== "string") continue;
-        const { count, max: lastModified } = row.value;
-        if (typeof count !== "number" || typeof lastModified !== "number")
-          continue;
-        yield {
-          value: {
-            channel: decodeURIComponent(channelEncoded),
-            count,
-            lastModified
-          }
-        };
-      }
-    }();
-  };
-  continueObjectStream = (cursor, session) => {
-    if (cursor.startsWith("discover:")) {
-      const { channels, schema, actor, ifModifiedSince } = JSON.parse(
-        cursor.slice("discover:".length)
-      );
-      if (actor && actor !== session?.actor) {
-        throw new GraffitiErrorForbidden(
-          "Cannot continue a cursor for another actor"
-        );
-      }
-      return this.discoverContinue(
-        [channels, schema, session],
-        ifModifiedSince
-      );
-    } else if (cursor.startsWith("orphans:")) {
-      const { schema, actor, ifModifiedSince } = JSON.parse(
-        cursor.slice("orphans:".length)
-      );
-      if (!session || actor !== session?.actor) {
-        throw new GraffitiErrorForbidden(
-          "Cannot continue a cursor for another actor"
-        );
-      }
-      return this.recoverOrphansContinue(
-        [schema, session],
-        ifModifiedSince
-      );
-    } else {
-      throw new GraffitiErrorNotFound("Cursor not found");
-    }
-  };
-}
-export {
-  GraffitiLocalDatabase
-};
-//# sourceMappingURL=database.js.map