@fedify/fedify 1.0.0-dev.409 → 1.0.0-dev.411

package/CHANGES.md

@@ -133,6 +133,18 @@ To be released.
     it's terminated so that the peers can clean up data related to the temporary
     actor.  [[#135]]
 
+ -  Add options for PostgreSQL drivers to `fedify init` command.
+
+     -  Added `postgres` value to the `-k`/`--kv-store` option of the `fedify
+        init` command.
+     -  Added `postgres` value to the `-q`/`--message-queue` option of
+        the `fedify init` command.
+
+ -  The generated project by the `fedify init` command now enables dotenv
+    by default.
+
+ -  The `fedify init` command now generates *.env* file with default values.
+
  -  Added more log messages using the [LogTape] library.  Currently the below
     logger categories are used:
 

package/esm/deps/jsr.io/@std/encoding/{0.224.3 → 1.0.5}/_validate_binary_like.js

@@ -22,5 +22,5 @@ export function validateBinaryLike(source) {
     else if (source instanceof ArrayBuffer) {
         return new Uint8Array(source);
     }
-    throw new TypeError(`The input must be a Uint8Array, a string, or an ArrayBuffer. Received a value of the type ${getTypeName(source)}.`);
+    throw new TypeError(`Cannot validate the input as it must be a Uint8Array, a string, or an ArrayBuffer: received a value of the type ${getTypeName(source)}`);
 }

package/esm/deps/jsr.io/@std/encoding/{0.224.3 → 1.0.5}/base64.js

@@ -5,14 +5,12 @@
  * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-4 | base64}
  * encoding and decoding.
  *
- * This module is browser compatible.
- *
  * ```ts
  * import {
  *   encodeBase64,
  *   decodeBase64,
  * } from "@std/encoding/base64";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * const foobar = new TextEncoder().encode("foobar");
  *
@@ -100,7 +98,7 @@ const base64abc = [
  * @example Usage
  * ```ts
  * import { encodeBase64 } from "@std/encoding/base64";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(encodeBase64("foobar"), "Zm9vYmFy");
  * ```
@@ -146,7 +144,7 @@ export function encodeBase64(data) {
  * @example Usage
  * ```ts
  * import { decodeBase64 } from "@std/encoding/base64";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(
  *   decodeBase64("Zm9vYmFy"),

package/esm/deps/jsr.io/@std/encoding/{0.224.3 → 1.0.5}/base64url.js

@@ -5,8 +5,6 @@
  * {@link https://www.rfc-editor.org/rfc/rfc4648.html#section-5 | base64url}
  * encoding and decoding.
  *
- * This module is browser compatible.
- *
  * @module
  */
 import * as base64 from "./base64.js";
@@ -22,7 +20,7 @@ function addPaddingToBase64url(base64url) {
     if (base64url.length % 4 === 3)
         return base64url + "=";
     if (base64url.length % 4 === 1) {
-        throw new TypeError("Illegal base64url string!");
+        throw new TypeError("Illegal base64url string");
     }
     return base64url;
 }
@@ -51,7 +49,7 @@ function convertBase64ToBase64url(b64) {
  * @example Usage
  * ```ts
  * import { encodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(encodeBase64Url("foobar"), "Zm9vYmFy");
  * ```
@@ -70,7 +68,7 @@ export function encodeBase64Url(data) {
  * @example Usage
  * ```ts
  * import { decodeBase64Url } from "@std/encoding/base64url";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(
  *   decodeBase64Url("Zm9vYmFy"),

package/esm/deps/jsr.io/@std/encoding/{0.224.3 → 1.0.5}/hex.js

@@ -7,14 +7,12 @@
  * {@link https://github.com/golang/go/blob/go1.12.5/src/encoding/hex/hex.go | encoding/hex}
  * library.
  *
- * This module is browser compatible.
- *
  * ```ts
  * import {
  *   decodeHex,
  *   encodeHex,
  * } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(encodeHex("abc"), "616263");
  *
@@ -33,8 +31,8 @@ const textDecoder = new TextDecoder();
 function errInvalidByte(byte) {
     return new TypeError(`Invalid byte '${String.fromCharCode(byte)}'`);
 }
-function errLength() {
-    return new RangeError("Odd length hex string");
+function errLength(len) {
+    return new RangeError(`Cannot decode the hex string as the input length should be even: length is ${len}`);
 }
 /** Converts a hex character into its value. */
 function fromHexChar(byte) {
@@ -59,7 +57,7 @@ function fromHexChar(byte) {
  * @example Usage
  * ```ts
  * import { encodeHex } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(encodeHex("abc"), "616263");
  * ```
@@ -67,7 +65,7 @@ function fromHexChar(byte) {
 export function encodeHex(src) {
     const u8 = validateBinaryLike(src);
     const dst = new Uint8Array(u8.length * 2);
-    for (let i = 0; i < dst.length; i++) {
+    for (let i = 0; i < u8.length; i++) {
         const v = u8[i];
         dst[i * 2] = hexTable[v >> 4];
         dst[i * 2 + 1] = hexTable[v & 0x0f];
@@ -85,7 +83,7 @@ export function encodeHex(src) {
  * @example Usage
  * ```ts
  * import { decodeHex } from "@std/encoding/hex";
- * import { assertEquals } from "@std/assert/assert-equals";
+ * import { assertEquals } from "@std/assert";
  *
  * assertEquals(
  *   decodeHex("616263"),
@@ -105,7 +103,7 @@ export function decodeHex(src) {
         // Check for invalid char before reporting bad length,
         // since the invalid char (if present) is an earlier problem.
         fromHexChar(u8[dst.length * 2]);
-        throw errLength();
+        throw errLength(u8.length);
     }
     return dst;
 }

package/esm/deps/jsr.io/@std/http/{0.224.5 → 1.0.6}/_negotiation/encoding.js

@@ -47,7 +47,7 @@ function parseEncoding(str, i) {
             }
         }
     }
-    return { encoding, q, i };
+    return { encoding, o: undefined, q, i, s: undefined };
 }
 function specify(encoding, spec, i = -1) {
     if (!spec.encoding) {
@@ -83,8 +83,10 @@ function parseAcceptEncoding(accept) {
     if (!hasIdentity) {
         parsedAccepts.push({
             encoding: "identity",
+            o: undefined,
             q: minQuality,
             i: accepts.length - 1,
+            s: undefined,
         });
     }
     return parsedAccepts;

package/esm/deps/jsr.io/@std/http/{0.224.5 → 1.0.6}/_negotiation/language.js

@@ -39,7 +39,7 @@ function parseLanguage(str, i) {
     if (!prefix) {
         return undefined;
     }
-    const full = suffix ? `${prefix}-${suffix}` : prefix;
+    const full = suffix !== undefined ? `${prefix}-${suffix}` : prefix;
     let q = 1;
     if (match[3]) {
         const params = match[3].split(";");
@@ -51,7 +51,7 @@ function parseLanguage(str, i) {
             }
         }
     }
-    return { prefix, suffix, full, q, i };
+    return { prefix, suffix, full, i, o: undefined, q, s: undefined };
 }
 function parseAcceptLanguage(accept) {
     const accepts = accept.split(",");

package/esm/deps/jsr.io/@std/http/{0.224.5 → 1.0.6}/_negotiation/media_type.js

@@ -58,7 +58,7 @@ function parseMediaType(str, i) {
             params[key] = value;
         }
     }
-    return { type, subtype, params, q, i };
+    return { type, subtype, params, i, o: undefined, q, s: undefined };
 }
 function parseAccept(accept) {
     const accepts = accept.split(",").map((p) => p.trim());
@@ -94,8 +94,8 @@ function specify(type, spec, index) {
     }
     const keys = Object.keys(spec.params);
     if (keys.length) {
-        if (keys.every((key) => (spec.params[key] || "").toLowerCase() ===
-            (p.params[key] || "").toLowerCase())) {
+        if (keys.every((key) => (spec.params[key] ?? "").toLowerCase() ===
+            (p.params[key] ?? "").toLowerCase())) {
             s |= 1;
         }
         else {
@@ -114,16 +114,16 @@ function getMediaTypePriority(type, accepted, index) {
     for (const accepts of accepted) {
         const spec = specify(type, accepts, index);
         if (spec &&
-            ((priority.s || 0) - (spec.s || 0) ||
-                (priority.q || 0) - (spec.q || 0) ||
-                (priority.o || 0) - (spec.o || 0)) < 0) {
+            ((priority.s ?? 0) - (spec.s ?? 0) ||
+                (priority.q ?? 0) - (spec.q ?? 0) ||
+                (priority.o ?? 0) - (spec.o ?? 0)) < 0) {
             priority = spec;
         }
     }
     return priority;
 }
 export function preferredMediaTypes(accept, provided) {
-    const accepts = parseAccept(accept === undefined ? "*/*" : accept || "");
+    const accepts = parseAccept(accept === undefined ? "*/*" : accept ?? "");
     if (!provided) {
         return accepts
             .filter(isQuality)

package/esm/deps/jsr.io/@std/semver/1.0.3/_constants.js

@@ -0,0 +1,38 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+/**
+ * The minimum valid SemVer object. Equivalent to `0.0.0`.
+ */
+export const MIN = {
+    major: 0,
+    minor: 0,
+    patch: 0,
+    prerelease: [],
+    build: [],
+};
+/**
+ * ANY is a sentinel value used by some range calculations. It is not a valid
+ * SemVer object and should not be used directly.
+ */
+export const ANY = {
+    major: Number.NaN,
+    minor: Number.NaN,
+    patch: Number.NaN,
+    prerelease: [],
+    build: [],
+};
+/**
+ * A comparator which will span all valid semantic versions
+ */
+export const ALL = {
+    operator: undefined,
+    ...ANY,
+};
+export const OPERATORS = [
+    undefined,
+    "=",
+    "!=",
+    ">",
+    ">=",
+    "<",
+    "<=",
+];

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/_shared.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 export function compareNumber(a, b) {
-    if (isNaN(a) || isNaN(b))
-        throw new Error("Comparison against non-numbers");
+    if (isNaN(a) || isNaN(b)) {
+        throw new Error("Cannot compare against non-numbers");
+    }
     return a === b ? 0 : a < b ? -1 : 1;
 }
 export function checkIdentifier(v1 = [], v2 = []) {

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/can_parse.js

@@ -13,18 +13,15 @@ import { parse } from "./parse.js";
  * assertFalse(canParse("invalid"));
  * ```
  *
- * @param version The version string to check
+ * @param value The version string to check
  * @returns `true` if the string can be parsed as SemVer, `false` otherwise
  */
-export function canParse(version) {
+export function canParse(value) {
     try {
-        parse(version);
+        parse(value);
         return true;
     }
-    catch (err) {
-        if (!(err instanceof TypeError)) {
-            throw err;
-        }
+    catch {
         return false;
     }
 }

package/esm/deps/jsr.io/@std/semver/1.0.3/compare.js

@@ -0,0 +1,35 @@
+import { checkIdentifier, compareIdentifier, compareNumber, } from "./_shared.js";
+/**
+ * Compare two SemVers.
+ *
+ * Returns `0` if `version1` equals `version2`, or `1` if `version1` is greater, or `-1` if `version2` is
+ * greater.
+ *
+ * Sorts in ascending order if passed to {@linkcode Array.sort}.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, compare } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assertEquals(compare(version1, version2), -1);
+ * assertEquals(compare(version2, version1), 1);
+ * assertEquals(compare(version1, version1), 0);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `1` if `version1` is greater, `0` if equal, or `-1` if `version2` is greater
+ */
+export function compare(version1, version2) {
+    if (version1 === version2)
+        return 0;
+    return (compareNumber(version1.major, version2.major) ||
+        compareNumber(version1.minor, version2.minor) ||
+        compareNumber(version1.patch, version2.patch) ||
+        checkIdentifier(version1.prerelease, version2.prerelease) ||
+        compareIdentifier(version1.prerelease, version2.prerelease));
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/difference.js

@@ -0,0 +1,41 @@
+import { compareIdentifier } from "./_shared.js";
+/**
+ * Returns difference between two SemVers by the release type,
+ * or `undefined` if the SemVers are the same.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, difference } from "@std/semver";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ * const version3 = parse("1.3.0");
+ * const version4 = parse("2.0.0");
+ *
+ * assertEquals(difference(version1, version2), "patch");
+ * assertEquals(difference(version1, version3), "minor");
+ * assertEquals(difference(version1, version4), "major");
+ * assertEquals(difference(version1, version1), undefined);
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns The release type difference or `undefined` if the versions are the same
+ */
+export function difference(version1, version2) {
+    const hasPrerelease = version1.prerelease?.length ||
+        version2.prerelease?.length;
+    if (version1.major !== version2.major) {
+        return hasPrerelease ? "premajor" : "major";
+    }
+    if (version1.minor !== version2.minor) {
+        return hasPrerelease ? "preminor" : "minor";
+    }
+    if (version1.patch !== version2.patch) {
+        return hasPrerelease ? "prepatch" : "patch";
+    }
+    if (compareIdentifier(version1.prerelease, version2.prerelease) !== 0) {
+        return "prerelease";
+    }
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/equals.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Returns `true` if both SemVers are equivalent.
+ *
+ * This is equal to `compare(version1, version2) === 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, equals } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.3");
+ *
+ * assert(equals(version1, version2));
+ * assert(!equals(version1, parse("1.2.4")));
+ * ```
+ *
+ * @param version1 The first SemVer to compare
+ * @param version2 The second SemVer to compare
+ * @returns `true` if `version1` is equal to `version2`, `false` otherwise
+ */
+export function equals(version1, version2) {
+    return compare(version1, version2) === 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/format.js

@@ -0,0 +1,32 @@
+function formatNumber(value) {
+    return value.toFixed(0);
+}
+/**
+ * Format a SemVer object into a string.
+ *
+ * @example Usage
+ * ```ts
+ * import { format } from "@std/semver/format";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const semver = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ * };
+ * assertEquals(format(semver), "1.2.3");
+ * ```
+ *
+ * @param version The SemVer to format
+ * @returns The string representation of a semantic version.
+ */
+export function format(version) {
+    const major = formatNumber(version.major);
+    const minor = formatNumber(version.minor);
+    const patch = formatNumber(version.patch);
+    const pre = version.prerelease?.join(".") ?? "";
+    const build = version.build?.join(".") ?? "";
+    const primary = `${major}.${minor}.${patch}`;
+    const release = [primary, pre].filter((v) => v).join("-");
+    return [release, build].filter((v) => v).join("+");
+}

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/format_range.js

@@ -1,12 +1,14 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { format } from "./format.js";
+import { isWildcardComparator } from "./_shared.js";
 function formatComparator(comparator) {
     const { operator } = comparator;
-    return `${operator === undefined ? "" : operator}${format(comparator)}`;
+    return `${operator === undefined ? "" : operator}${isWildcardComparator(comparator) ? "*" : format(comparator)}`;
 }
 /**
- * Formats the range into a string
+ * Formats the SemVerrange into a string.
+ *
  * @example Usage
  * ```ts
  * import { formatRange, parseRange } from "@std/semver";
@@ -17,7 +19,7 @@ function formatComparator(comparator) {
  * ```
  *
  * @param range The range to format
- * @returns A string representation of the range
+ * @returns A string representation of the SemVer range
  */
 export function formatRange(range) {
     return range.map((c) => c.map((c) => formatComparator(c)).join(" "))

package/esm/deps/jsr.io/@std/semver/1.0.3/greater_or_equal.js

@@ -0,0 +1,26 @@
+import { compare } from "./compare.js";
+/**
+ * Greater than or equal to comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) >= 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterOrEqual } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterOrEqual(version2, version1));
+ * assert(!greaterOrEqual(version1, version2));
+ * assert(greaterOrEqual(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than or equal to `version2`, `false` otherwise
+ */
+export function greaterOrEqual(version1, version2) {
+    return compare(version1, version2) >= 0;
+}

package/esm/deps/jsr.io/@std/semver/1.0.3/greater_than.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { compare } from "./compare.js";
+/**
+ * Greater than comparison for two SemVers.
+ *
+ * This is equal to `compare(version1, version2) > 0`.
+ *
+ * @example Usage
+ * ```ts
+ * import { parse, greaterThan } from "@std/semver";
+ * import { assert } from "@std/assert";
+ *
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
+ *
+ * assert(greaterThan(version2, version1));
+ * assert(!greaterThan(version1, version2));
+ * assert(!greaterThan(version1, version1));
+ * ```
+ *
+ * @param version1 The first version to compare
+ * @param version2 The second version to compare
+ * @returns `true` if `version1` is greater than `version2`, `false` otherwise
+ */
+export function greaterThan(version1, version2) {
+    return compare(version1, version2) > 0;
+}

package/esm/deps/jsr.io/@std/semver/{0.224.3 → 1.0.3}/greater_than_range.js

@@ -9,36 +9,37 @@ import { compare } from "./compare.js";
  * @example Usage
  * ```ts
  * import { parse, parseRange, greaterThanRange } from "@std/semver";
- * import { assert, assertFalse } from "@std/assert";
+ * import { assert } from "@std/assert";
  *
- * const v0 = parse("1.2.3");
- * const v1 = parse("1.2.4");
+ * const version1 = parse("1.2.3");
+ * const version2 = parse("1.2.4");
  * const range = parseRange(">=1.2.3 <1.2.4");
- * assertFalse(greaterThanRange(v0, range));
- * assert(greaterThanRange(v1, range));
+ *
+ * assert(!greaterThanRange(version1, range));
+ * assert(greaterThanRange(version2, range));
  * ```
  *
- * @param semver The version to check.
+ * @param version The version to check.
  * @param range The range to check against.
  * @returns `true` if the semver is greater than the range, `false` otherwise.
  */
-export function greaterThanRange(semver, range) {
-    return range.every((comparatorSet) => greaterThanComparatorSet(semver, comparatorSet));
+export function greaterThanRange(version, range) {
+    return range.every((comparatorSet) => greaterThanComparatorSet(version, comparatorSet));
 }
-function greaterThanComparatorSet(semver, comparatorSet) {
+function greaterThanComparatorSet(version, comparatorSet) {
     // If the comparator set contains wildcard, then the semver is not greater than the range.
     if (comparatorSet.some(isWildcardComparator))
         return false;
     // If the semver satisfies the comparator set, then it's not greater than the range.
-    if (testComparatorSet(semver, comparatorSet))
+    if (testComparatorSet(version, comparatorSet))
         return false;
     // If the semver is less than any of the comparator set, then it's not greater than the range.
-    if (comparatorSet.some((comparator) => lessThanComparator(semver, comparator)))
+    if (comparatorSet.some((comparator) => lessThanComparator(version, comparator)))
         return false;
     return true;
 }
-function lessThanComparator(semver, comparator) {
-    const cmp = compare(semver, comparator);
+function lessThanComparator(version, comparator) {
+    const cmp = compare(version, comparator);
     switch (comparator.operator) {
         case "=":
         case undefined: