@arkiv-network/sdk 0.7.0 → 0.8.0-advanced.3

package/dist/payload-DaPzUvEh.js

@@ -0,0 +1,92 @@
+import { i as MAX_EXPIRES_AT, r as toBlocks, t as makeExpiry } from "./expiry-CZErShX6.js";
+import { n as InvalidExpiryError } from "./errors-CwPJ16bn.js";
+import { stringToBytes, toBytes } from "viem";
+
+//#region src/utils/expirationTime.ts
+function lifetimeOf(seconds) {
+	return makeExpiry(toBlocks(seconds), 0n);
+}
+function deadlineOf(expiresAt, options) {
+	return makeExpiry(options?.atLeast?.minLifetime ?? 0n, expiresAt);
+}
+/**
+* Builds the `expires` of a create or an extension.
+*
+* Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is
+* what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;
+* {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes
+* whichever comes later, which is why a deadline can also carry a floor.
+*
+* Values are plain data — no methods, no prototype — so they log, clone and compare like any other
+* object.
+*
+* @example The 90% case: a duration, and nothing else to think about.
+* await client.createEntity({ payload, contentType, expires: ExpirationTime.fromDays(30) })
+*
+* @example An exact block, or a wall-clock date.
+* expires: ExpirationTime.atBlock(1_200_000n)
+* expires: ExpirationTime.atDate(new Date("2027-01-01"))
+*
+* @example A deadline that still guarantees a minimum life.
+* expires: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })
+*/
+const ExpirationTime = {
+	fromSeconds: (seconds) => lifetimeOf(seconds),
+	fromMinutes: (minutes) => lifetimeOf(minutes * 60),
+	fromHours: (hours) => lifetimeOf(hours * 60 * 60),
+	fromDays: (days) => lifetimeOf(days * 24 * 60 * 60),
+	fromWeeks: (weeks) => lifetimeOf(weeks * 7 * 24 * 60 * 60),
+	fromMonths: (months) => lifetimeOf(months * 30 * 24 * 60 * 60),
+	fromYears: (years) => lifetimeOf(years * 365 * 24 * 60 * 60),
+	fromBlocks: (blocks) => {
+		if (!Number.isInteger(blocks) || blocks <= 0) throw new InvalidExpiryError(`a lifetime must be a positive whole number of blocks, got ${blocks}`);
+		return makeExpiry(BigInt(blocks), 0n);
+	},
+	atBlock: (block, options) => {
+		if (typeof block !== "bigint" || block < 0n) throw new InvalidExpiryError(`a deadline must be a non-negative block height, got ${block}`);
+		return deadlineOf(block, options);
+	},
+	atDate: (date, options) => {
+		if (!(date instanceof Date) || Number.isNaN(date.getTime())) throw new InvalidExpiryError(`a deadline must be a valid Date, got ${String(date)}`);
+		return deadlineOf(date, options);
+	},
+	permanent: () => deadlineOf(MAX_EXPIRES_AT)
+};
+
+//#endregion
+//#region src/utils/payload.ts
+/**
+* A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.
+*
+* Pair it with `contentType: "application/json"`, which is what lets `entity.toJson()` read it back.
+*
+* @example
+* await client.createEntity({
+*   payload: jsonToPayload({ hello: "world" }),
+*   contentType: "application/json",
+*   expires: ExpirationTime.fromDays(30),
+* })
+*/
+function jsonToPayload(json) {
+	return toBytes(JSON.stringify(json));
+}
+/**
+* A string as an entity payload, encoded as UTF-8.
+*
+* Hex-looking text is encoded as text: `stringToPayload("0xab")` gives the four bytes of that
+* string, not the single byte `0xab`. Read it back with `entity.toText()`.
+*
+* @example
+* await client.createEntity({
+*   payload: stringToPayload("hello"),
+*   contentType: "text/plain",
+*   expires: ExpirationTime.fromDays(30),
+* })
+*/
+function stringToPayload(data) {
+	return stringToBytes(data);
+}
+
+//#endregion
+export { stringToPayload as n, ExpirationTime as r, jsonToPayload as t };
+//# sourceMappingURL=payload-DaPzUvEh.js.map

package/dist/payload-DaPzUvEh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-DaPzUvEh.js","names":[],"sources":["../src/utils/expirationTime.ts","../src/utils/payload.ts"],"sourcesContent":["import { InvalidExpiryError } from \"../entity/errors\"\nimport { type Expiry, type Lifetime, makeExpiry, toBlocks } from \"../entity/expiry\"\nimport { MAX_EXPIRES_AT } from \"../entity/params\"\n\n/**\n * The optional floor a deadline can carry.\n *\n * `atLeast` takes a duration — one of the `from*` helpers — and never another deadline, so\n * `atBlock(x, { atLeast: atBlock(y) })` does not compile. Two deadlines are not a thing the engine\n * can resolve.\n */\nexport type DeadlineOptions = {\n  /** Live at least this long from now, even if the deadline is sooner. */\n  atLeast?: Lifetime | undefined\n}\n\nfunction lifetimeOf(seconds: number): Lifetime {\n  return makeExpiry(toBlocks(seconds), 0n) as Lifetime\n}\n\nfunction deadlineOf(expiresAt: bigint | Date, options?: DeadlineOptions): Expiry {\n  return makeExpiry(options?.atLeast?.minLifetime ?? 0n, expiresAt)\n}\n\n/**\n * Builds the `expires` of a create or an extension.\n *\n * Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is\n * what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;\n * {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes\n * whichever comes later, which is why a deadline can also carry a floor.\n *\n * Values are plain data — no methods, no prototype — so they log, clone and compare like any other\n * object.\n *\n * @example The 90% case: a duration, and nothing else to think about.\n * await client.createEntity({ payload, contentType, expires: ExpirationTime.fromDays(30) })\n *\n * @example An exact block, or a wall-clock date.\n * expires: ExpirationTime.atBlock(1_200_000n)\n * expires: ExpirationTime.atDate(new Date(\"2027-01-01\"))\n *\n * @example A deadline that still guarantees a minimum life.\n * expires: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })\n */\nexport const ExpirationTime = {\n  /**\n   * A raw number of seconds. Must be a whole number of blocks' worth — see the other helpers, which\n   * all produce one by construction.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromSeconds: (seconds: number): Lifetime => lifetimeOf(seconds),\n  /**\n   * A number of minutes.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMinutes: (minutes: number): Lifetime => lifetimeOf(minutes * 60),\n\n  /**\n   * A number of hours.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromHours: (hours: number): Lifetime => lifetimeOf(hours * 60 * 60),\n\n  /**\n   * A number of days. The everyday form — `fromDays(30)` is what most creates want.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromDays: (days: number): Lifetime => lifetimeOf(days * 24 * 60 * 60),\n\n  /**\n   * A number of weeks, each of 7 days.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromWeeks: (weeks: number): Lifetime => lifetimeOf(weeks * 7 * 24 * 60 * 60),\n\n  /**\n   * A number of months, each of exactly **30 days** — calendar months are not all the same length,\n   * and a lifetime is a duration rather than a date. Use {@link ExpirationTime.atDate} when the\n   * expiry has to land on a particular calendar day.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromMonths: (months: number): Lifetime => lifetimeOf(months * 30 * 24 * 60 * 60),\n\n  /**\n   * A number of years, each of exactly **365 days** — leap days are not counted, so `fromYears(4)`\n   * is a day short of four calendar years. Use {@link ExpirationTime.atDate} for a calendar\n   * deadline.\n   *\n   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.\n   */\n  fromYears: (years: number): Lifetime => lifetimeOf(years * 365 * 24 * 60 * 60),\n\n  /**\n   * A number of blocks, for callers who think in the chain's own unit. Always exact — there is no\n   * conversion to be approximate about.\n   *\n   * @throws {InvalidExpiryError} If the count is not a positive whole number.\n   */\n  fromBlocks: (blocks: number): Lifetime => {\n    if (!Number.isInteger(blocks) || blocks <= 0) {\n      throw new InvalidExpiryError(\n        `a lifetime must be a positive whole number of blocks, got ${blocks}`,\n      )\n    }\n    return makeExpiry(BigInt(blocks), 0n) as Lifetime\n  },\n\n  /**\n   * An absolute block height.\n   *\n   * @param block - The block the entity expires at.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the height is negative.\n   */\n  atBlock: (block: bigint, options?: DeadlineOptions): Expiry => {\n    if (typeof block !== \"bigint\" || block < 0n) {\n      throw new InvalidExpiryError(`a deadline must be a non-negative block height, got ${block}`)\n    }\n    return deadlineOf(block, options)\n  },\n\n  /**\n   * A wall-clock instant, placed against the block the transaction is built on.\n   *\n   * A date cannot land on a block boundary in general, so it rounds **up** to the next block: the\n   * entity lives until at least the instant asked for. This is why a date is never rejected for\n   * \"not being a whole number of blocks\" the way a duration is — it becomes a block height, not a\n   * duration.\n   *\n   * @param date - When the entity should expire.\n   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.\n   * @throws {InvalidExpiryError} If the value is not a valid `Date`.\n   */\n  atDate: (date: Date, options?: DeadlineOptions): Expiry => {\n    if (!(date instanceof Date) || Number.isNaN(date.getTime())) {\n      throw new InvalidExpiryError(`a deadline must be a valid Date, got ${String(date)}`)\n    }\n    return deadlineOf(date, options)\n  },\n\n  /**\n   * An entity that should never expire.\n   *\n   * This is `atBlock(MAX_EXPIRES_AT)` — the largest expiry the `uint64` field holds — and the\n   * engine treats it as an ordinary deadline rather than a special case. There is no permanence\n   * flag; a block height no chain will reach is what permanence is.\n   */\n  permanent: (): Expiry => deadlineOf(MAX_EXPIRES_AT),\n}\n","import { stringToBytes, toBytes } from \"viem\"\n\n/**\n * A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.\n *\n * Pair it with `contentType: \"application/json\"`, which is what lets `entity.toJson()` read it back.\n *\n * @example\n * await client.createEntity({\n *   payload: jsonToPayload({ hello: \"world\" }),\n *   contentType: \"application/json\",\n *   expires: ExpirationTime.fromDays(30),\n * })\n */\nexport function jsonToPayload(json: object): Uint8Array {\n  return toBytes(JSON.stringify(json))\n}\n\n/**\n * A string as an entity payload, encoded as UTF-8.\n *\n * Hex-looking text is encoded as text: `stringToPayload(\"0xab\")` gives the four bytes of that\n * string, not the single byte `0xab`. Read it back with `entity.toText()`.\n *\n * @example\n * await client.createEntity({\n *   payload: stringToPayload(\"hello\"),\n *   contentType: \"text/plain\",\n *   expires: ExpirationTime.fromDays(30),\n * })\n */\nexport function stringToPayload(data: string): Uint8Array {\n  // stringToBytes, not toBytes: toBytes hex-decodes hex-looking strings, which\n  // would corrupt payloads like \"0xab\" instead of UTF-8 encoding them\n  return stringToBytes(data)\n}\n"],"mappings":";;;;;AAgBA,SAAS,WAAW,SAA2B;AAC7C,QAAO,WAAW,SAAS,QAAQ,EAAE,GAAG;;AAG1C,SAAS,WAAW,WAA0B,SAAmC;AAC/E,QAAO,WAAW,SAAS,SAAS,eAAe,IAAI,UAAU;;;;;;;;;;;;;;;;;;;;;;;AAwBnE,MAAa,iBAAiB;CAO5B,cAAc,YAA8B,WAAW,QAAQ;CAM/D,cAAc,YAA8B,WAAW,UAAU,GAAG;CAOpE,YAAY,UAA4B,WAAW,QAAQ,KAAK,GAAG;CAOnE,WAAW,SAA2B,WAAW,OAAO,KAAK,KAAK,GAAG;CAOrE,YAAY,UAA4B,WAAW,QAAQ,IAAI,KAAK,KAAK,GAAG;CAS5E,aAAa,WAA6B,WAAW,SAAS,KAAK,KAAK,KAAK,GAAG;CAShF,YAAY,UAA4B,WAAW,QAAQ,MAAM,KAAK,KAAK,GAAG;CAQ9E,aAAa,WAA6B;AACxC,MAAI,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACzC,OAAM,IAAI,mBACR,6DAA6D,SAC9D;AAEH,SAAO,WAAW,OAAO,OAAO,EAAE,GAAG;;CAUvC,UAAU,OAAe,YAAsC;AAC7D,MAAI,OAAO,UAAU,YAAY,QAAQ,GACvC,OAAM,IAAI,mBAAmB,uDAAuD,QAAQ;AAE9F,SAAO,WAAW,OAAO,QAAQ;;CAenC,SAAS,MAAY,YAAsC;AACzD,MAAI,EAAE,gBAAgB,SAAS,OAAO,MAAM,KAAK,SAAS,CAAC,CACzD,OAAM,IAAI,mBAAmB,wCAAwC,OAAO,KAAK,GAAG;AAEtF,SAAO,WAAW,MAAM,QAAQ;;CAUlC,iBAAyB,WAAW,eAAe;CACpD;;;;;;;;;;;;;;;;AC7ID,SAAgB,cAAc,MAA0B;AACtD,QAAO,QAAQ,KAAK,UAAU,KAAK,CAAC;;;;;;;;;;;;;;;AAgBtC,SAAgB,gBAAgB,MAA0B;AAGxD,QAAO,cAAc,KAAK"}

package/dist/payload-hluX1rc0.d.cts

@@ -0,0 +1,153 @@
+import { i as Lifetime, n as Expiry } from "./expiry-DRV29F1r.cjs";
+
+//#region src/utils/expirationTime.d.ts
+
+/**
+ * The optional floor a deadline can carry.
+ *
+ * `atLeast` takes a duration — one of the `from*` helpers — and never another deadline, so
+ * `atBlock(x, { atLeast: atBlock(y) })` does not compile. Two deadlines are not a thing the engine
+ * can resolve.
+ */
+type DeadlineOptions = {
+  /** Live at least this long from now, even if the deadline is sooner. */
+  atLeast?: Lifetime | undefined;
+};
+/**
+ * Builds the `expires` of a create or an extension.
+ *
+ * Every helper returns the `{ minLifetime, expiresAt }` pair the ABI carries, so what you write is
+ * what goes on the wire. The `from*` helpers fill `minLifetime` and leave `expiresAt` at `0n`;
+ * {@link ExpirationTime.atBlock} and {@link ExpirationTime.atDate} do the reverse. The engine takes
+ * whichever comes later, which is why a deadline can also carry a floor.
+ *
+ * Values are plain data — no methods, no prototype — so they log, clone and compare like any other
+ * object.
+ *
+ * @example The 90% case: a duration, and nothing else to think about.
+ * await client.createEntity({ payload, contentType, expires: ExpirationTime.fromDays(30) })
+ *
+ * @example An exact block, or a wall-clock date.
+ * expires: ExpirationTime.atBlock(1_200_000n)
+ * expires: ExpirationTime.atDate(new Date("2027-01-01"))
+ *
+ * @example A deadline that still guarantees a minimum life.
+ * expires: ExpirationTime.atBlock(1_200_000n, { atLeast: ExpirationTime.fromDays(1) })
+ */
+declare const ExpirationTime: {
+  /**
+   * A raw number of seconds. Must be a whole number of blocks' worth — see the other helpers, which
+   * all produce one by construction.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromSeconds: (seconds: number) => Lifetime;
+  /**
+   * A number of minutes.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromMinutes: (minutes: number) => Lifetime;
+  /**
+   * A number of hours.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromHours: (hours: number) => Lifetime;
+  /**
+   * A number of days. The everyday form — `fromDays(30)` is what most creates want.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromDays: (days: number) => Lifetime;
+  /**
+   * A number of weeks, each of 7 days.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromWeeks: (weeks: number) => Lifetime;
+  /**
+   * A number of months, each of exactly **30 days** — calendar months are not all the same length,
+   * and a lifetime is a duration rather than a date. Use {@link ExpirationTime.atDate} when the
+   * expiry has to land on a particular calendar day.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromMonths: (months: number) => Lifetime;
+  /**
+   * A number of years, each of exactly **365 days** — leap days are not counted, so `fromYears(4)`
+   * is a day short of four calendar years. Use {@link ExpirationTime.atDate} for a calendar
+   * deadline.
+   *
+   * @throws {InvalidExpiryError} If the duration is not a positive multiple of the block time.
+   */
+  fromYears: (years: number) => Lifetime;
+  /**
+   * A number of blocks, for callers who think in the chain's own unit. Always exact — there is no
+   * conversion to be approximate about.
+   *
+   * @throws {InvalidExpiryError} If the count is not a positive whole number.
+   */
+  fromBlocks: (blocks: number) => Lifetime;
+  /**
+   * An absolute block height.
+   *
+   * @param block - The block the entity expires at.
+   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.
+   * @throws {InvalidExpiryError} If the height is negative.
+   */
+  atBlock: (block: bigint, options?: DeadlineOptions) => Expiry;
+  /**
+   * A wall-clock instant, placed against the block the transaction is built on.
+   *
+   * A date cannot land on a block boundary in general, so it rounds **up** to the next block: the
+   * entity lives until at least the instant asked for. This is why a date is never rejected for
+   * "not being a whole number of blocks" the way a duration is — it becomes a block height, not a
+   * duration.
+   *
+   * @param date - When the entity should expire.
+   * @param options - Optionally, a floor: `{ atLeast: ExpirationTime.fromDays(1) }`.
+   * @throws {InvalidExpiryError} If the value is not a valid `Date`.
+   */
+  atDate: (date: Date, options?: DeadlineOptions) => Expiry;
+  /**
+   * An entity that should never expire.
+   *
+   * This is `atBlock(MAX_EXPIRES_AT)` — the largest expiry the `uint64` field holds — and the
+   * engine treats it as an ordinary deadline rather than a special case. There is no permanence
+   * flag; a block height no chain will reach is what permanence is.
+   */
+  permanent: () => Expiry;
+};
+//#endregion
+//#region src/utils/payload.d.ts
+/**
+ * A JSON-serialisable value as an entity payload — `JSON.stringify` then UTF-8.
+ *
+ * Pair it with `contentType: "application/json"`, which is what lets `entity.toJson()` read it back.
+ *
+ * @example
+ * await client.createEntity({
+ *   payload: jsonToPayload({ hello: "world" }),
+ *   contentType: "application/json",
+ *   expires: ExpirationTime.fromDays(30),
+ * })
+ */
+declare function jsonToPayload(json: object): Uint8Array;
+/**
+ * A string as an entity payload, encoded as UTF-8.
+ *
+ * Hex-looking text is encoded as text: `stringToPayload("0xab")` gives the four bytes of that
+ * string, not the single byte `0xab`. Read it back with `entity.toText()`.
+ *
+ * @example
+ * await client.createEntity({
+ *   payload: stringToPayload("hello"),
+ *   contentType: "text/plain",
+ *   expires: ExpirationTime.fromDays(30),
+ * })
+ */
+declare function stringToPayload(data: string): Uint8Array;
+//#endregion
+export { ExpirationTime as i, stringToPayload as n, DeadlineOptions as r, jsonToPayload as t };
+//# sourceMappingURL=payload-hluX1rc0.d.cts.map

package/dist/payload-hluX1rc0.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-hluX1rc0.d.cts","names":[],"sources":["../src/utils/expirationTime.ts","../src/utils/payload.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;AAkCA;;;;AA2B4B,KA7DhB,eAAA,GA6DgB;EAOE;EASE,OAAA,CAAA,EA3EpB,QA2EoB,GAAA,SAAA;CASF;;;;;;;;;;;;ACnF9B;AAiBA;;;;;;;;;cDca;;;;;;;oCAOqB;;;;;;oCAMA;;;;;;gCAOJ;;;;;;8BAOF;;;;;;gCAOE;;;;;;;;kCASE;;;;;;;;gCASF;;;;;;;kCAQE;;;;;;;;qCAgBK,oBAAkB;;;;;;;;;;;;;iBAmBtC,gBAAgB,oBAAkB;;;;;;;;mBAclC;;;;;;;AA/IjB;AAkCA;;;;;;;;AA4DgC,iBC3FhB,aAAA,CD2FgB,IAAA,EAAA,MAAA,CAAA,EC3Fa,UD2Fb;;;;;;;;;;;AC3FhC;AAiBA;;iBAAgB,eAAA,gBAA+B"}

package/dist/query/index.cjs

@@ -1,152 +1,29 @@
-const require_queryBuilder = require('../queryBuilder-UW2MCaX4.cjs');
-require('../consts-AUoL-v42.cjs');
+require('../attributes-CMJlp1wn.cjs');
+require('../errors-51znTSB1.cjs');
+require('../flags-Bh0HJldY.cjs');
+require('../logger-Cr15lPAQ.cjs');
+require('../attr-DlmErkvR.cjs');
+require('../entity-B00Li04j.cjs');
+const require_queryBuilder = require('../queryBuilder-BXR-HxD9.cjs');
 
-//#region src/query/predicate.ts
-function or(...predicates) {
-	return {
-		type: "or",
-		predicates: predicates.flat()
-	};
-}
-function and(...predicates) {
-	return {
-		type: "and",
-		predicates: predicates.flat()
-	};
-}
-/**
-* Creates an equality predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The equality predicate
-*
-* @example
-* const predicate = eq("name", "John")
-* // result = { type: "eq", key: "name", value: "John" }
-*/
-function eq(key, value) {
-	return {
-		type: "eq",
-		key,
-		value
-	};
-}
-/**
-* Creates a not equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The not equal predicate
-*
-* @example
-* const predicate = neq("name", "John")
-* // result = { type: "neq", key: "name", value: "John" }
-*/
-function neq(key, value) {
-	return {
-		type: "neq",
-		key,
-		value
-	};
-}
-/**
-* Creates a greater than predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The greater than predicate
-*
-* @example
-* const predicate = gt("name", "John")
-* // result = { type: "gt", key: "name", value: "John" }
-*/
-function gt(key, value) {
-	return {
-		type: "gt",
-		key,
-		value
-	};
-}
-/**
-* Creates a greater than or equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The greater than or equal predicate
-*
-* @example
-* const predicate = gte("name", "John")
-* // result = { type: "gte", key: "name", value: "John" }
-*/
-function gte(key, value) {
-	return {
-		type: "gte",
-		key,
-		value
-	};
-}
-/**
-* Creates a less than predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The less than predicate
-*
-* @example
-* const predicate = lt("name", "John")
-* // result = { type: "lt", key: "name", value: "John" }
-*/
-function lt(key, value) {
-	return {
-		type: "lt",
-		key,
-		value
-	};
-}
-/**
-* Creates a less than or equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The less than or equal predicate
-*
-* @example
-* const predicate = lte("name", "John")
-* // result = { type: "lte", key: "name", value: "John" }
-*/
-function lte(key, value) {
-	return {
-		type: "lte",
-		key,
-		value
-	};
-}
-/**
-* Creates a not predicate
-* @param key - The key to compare
-* @returns The not predicate
-*
-* @example
-* const predicate = not("name")
-* // result = { type: "not", key: "name", value: "" }
-*/
-function not(key) {
-	return {
-		type: "not",
-		key,
-		value: ""
-	};
-}
-
-//#endregion
-exports.BaseQueryBuilder = require_queryBuilder.BaseQueryBuilder;
-exports.QueryBuilder = require_queryBuilder.QueryBuilder;
+exports.InvalidPredicateError = require_queryBuilder.InvalidPredicateError;
+exports.MAX_LIMIT = require_queryBuilder.MAX_LIMIT;
+exports.QueryError = require_queryBuilder.QueryError;
 exports.QueryResult = require_queryBuilder.QueryResult;
 exports.SelectQueryBuilder = require_queryBuilder.SelectQueryBuilder;
-exports.and = and;
-exports.asc = require_queryBuilder.asc;
-exports.desc = require_queryBuilder.desc;
-exports.eq = eq;
-exports.gt = gt;
-exports.gte = gte;
-exports.lt = lt;
-exports.lte = lte;
-exports.neq = neq;
-exports.not = not;
-exports.or = or;
-exports.selectionToIncludeData = require_queryBuilder.selectionToIncludeData;
+exports.UnsupportedOperatorError = require_queryBuilder.UnsupportedOperatorError;
+exports.and = require_queryBuilder.and;
+exports.eq = require_queryBuilder.eq;
+exports.exists = require_queryBuilder.exists;
+exports.gt = require_queryBuilder.gt;
+exports.gte = require_queryBuilder.gte;
+exports.hasType = require_queryBuilder.hasType;
+exports.lt = require_queryBuilder.lt;
+exports.lte = require_queryBuilder.lte;
+exports.ne = require_queryBuilder.ne;
+exports.not = require_queryBuilder.not;
+exports.or = require_queryBuilder.or;
+exports.render = require_queryBuilder.render;
+exports.runQuery = require_queryBuilder.runQuery;
+exports.startsWith = require_queryBuilder.startsWith;
+exports.toRpcSelect = require_queryBuilder.toRpcSelect;

package/dist/query/index.d.cts

@@ -1,3 +1,5 @@
-import "../entity-B6g_EPm1.cjs";
-import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-Ds9dwqb5.cjs";
-export { BaseQueryBuilder, EntitySelection, FullEntity, OrderByAttribute, Predicate, PredicateContainerType, PredicateType, ProjectedEntity, QueryBuilder, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, and, asc, desc, eq, gt, gte, lt, lte, neq, not, or, selectionToIncludeData };
+import { A as startsWith, C as hasType, D as not, E as ne, O as or, S as gte, T as lte, _ as TypeOfNode, a as SelectionFields, b as exists, d as ComparisonOperator, f as ExistsNode, g as StartsWithNode, h as OrNode, i as SelectArg, k as render, l as AndNode, m as NotNode, n as FullEntity, o as toRpcSelect, p as Expression, r as ProjectedEntity, t as EntitySelection, u as ComparisonNode, v as and, w as lt, x as gt, y as eq } from "../selection-C6KeWJ7g.cjs";
+import "../index-NbfnXxgr.cjs";
+import "../flags-CRjPpoh3.cjs";
+import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-CMeD8uEq.cjs";
+export { AndNode, ComparisonNode, ComparisonOperator, EntitySelection, ExistsNode, Expression, FullEntity, InvalidPredicateError, MAX_LIMIT, NotNode, OrNode, ProjectedEntity, QueryError, QueryErrorKind, QueryRequest, QueryResponse, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, StartsWithNode, TypeOfNode, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };

package/dist/query/index.d.ts

@@ -1,3 +1,6 @@
-import "../entity-qoLMAuuk.js";
-import { C as neq, S as lte, T as or, _ as and, a as asc, b as gte, c as FullEntity, d as SelectionFields, f as selectionToIncludeData, g as PredicateType, h as PredicateContainerType, i as SelectQueryBuilder, l as ProjectedEntity, m as Predicate, n as OrderByAttribute, o as desc, p as QueryResult, r as QueryBuilder, s as EntitySelection, t as BaseQueryBuilder, u as SelectArg, v as eq, w as not, x as lt, y as gt } from "../index-DdspxNAA.js";
-export { BaseQueryBuilder, EntitySelection, FullEntity, OrderByAttribute, Predicate, PredicateContainerType, PredicateType, ProjectedEntity, QueryBuilder, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, and, asc, desc, eq, gt, gte, lt, lte, neq, not, or, selectionToIncludeData };
+import { A as startsWith, C as hasType, D as not, E as ne, O as or, S as gte, T as lte, _ as TypeOfNode, a as SelectionFields, b as exists, d as ComparisonOperator, f as ExistsNode, g as StartsWithNode, h as OrNode, i as SelectArg, k as render, l as AndNode, m as NotNode, n as FullEntity, o as toRpcSelect, p as Expression, r as ProjectedEntity, t as EntitySelection, u as ComparisonNode, v as and, w as lt, x as gt, y as eq } from "../selection-mjiiAGDO.js";
+import "../codec-M74UR1_0.js";
+import "../index-D0IzFwMX.js";
+import "../flags-5dTNRnow.js";
+import { a as QueryErrorKind, c as QueryRequest, i as QueryError, l as QueryResponse, n as QueryResult, o as UnsupportedOperatorError, r as InvalidPredicateError, s as MAX_LIMIT, t as SelectQueryBuilder, u as runQuery } from "../index-Dz4SkQWg.js";
+export { AndNode, ComparisonNode, ComparisonOperator, EntitySelection, ExistsNode, Expression, FullEntity, InvalidPredicateError, MAX_LIMIT, NotNode, OrNode, ProjectedEntity, QueryError, QueryErrorKind, QueryRequest, QueryResponse, QueryResult, SelectArg, SelectQueryBuilder, SelectionFields, StartsWithNode, TypeOfNode, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };

package/dist/query/index.js

@@ -1,138 +1,9 @@
-import { a as desc, i as asc, n as QueryBuilder, o as selectionToIncludeData, r as SelectQueryBuilder, s as QueryResult, t as BaseQueryBuilder } from "../queryBuilder-D2uwP9jI.js";
-import "../consts-BV4PR-de.js";
+import "../attributes-BJGuhsqp.js";
+import "../errors-CwPJ16bn.js";
+import "../flags-Cr76ldwF.js";
+import "../logger-CVpvU8ik.js";
+import "../attr-GcQKatub.js";
+import "../entity-BYQR1uoe.js";
+import { _ as MAX_LIMIT, a as eq, b as QueryError, c as gte, d as lte, f as ne, g as startsWith, h as render, i as and, l as hasType, m as or, n as QueryResult, o as exists, p as not, r as toRpcSelect, s as gt, t as SelectQueryBuilder, u as lt, v as runQuery, x as UnsupportedOperatorError, y as InvalidPredicateError } from "../queryBuilder-BwauPaGO.js";
 
-//#region src/query/predicate.ts
-function or(...predicates) {
-	return {
-		type: "or",
-		predicates: predicates.flat()
-	};
-}
-function and(...predicates) {
-	return {
-		type: "and",
-		predicates: predicates.flat()
-	};
-}
-/**
-* Creates an equality predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The equality predicate
-*
-* @example
-* const predicate = eq("name", "John")
-* // result = { type: "eq", key: "name", value: "John" }
-*/
-function eq(key, value) {
-	return {
-		type: "eq",
-		key,
-		value
-	};
-}
-/**
-* Creates a not equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The not equal predicate
-*
-* @example
-* const predicate = neq("name", "John")
-* // result = { type: "neq", key: "name", value: "John" }
-*/
-function neq(key, value) {
-	return {
-		type: "neq",
-		key,
-		value
-	};
-}
-/**
-* Creates a greater than predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The greater than predicate
-*
-* @example
-* const predicate = gt("name", "John")
-* // result = { type: "gt", key: "name", value: "John" }
-*/
-function gt(key, value) {
-	return {
-		type: "gt",
-		key,
-		value
-	};
-}
-/**
-* Creates a greater than or equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The greater than or equal predicate
-*
-* @example
-* const predicate = gte("name", "John")
-* // result = { type: "gte", key: "name", value: "John" }
-*/
-function gte(key, value) {
-	return {
-		type: "gte",
-		key,
-		value
-	};
-}
-/**
-* Creates a less than predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The less than predicate
-*
-* @example
-* const predicate = lt("name", "John")
-* // result = { type: "lt", key: "name", value: "John" }
-*/
-function lt(key, value) {
-	return {
-		type: "lt",
-		key,
-		value
-	};
-}
-/**
-* Creates a less than or equal predicate
-* @param key - The key to compare
-* @param value - The value to compare
-* @returns The less than or equal predicate
-*
-* @example
-* const predicate = lte("name", "John")
-* // result = { type: "lte", key: "name", value: "John" }
-*/
-function lte(key, value) {
-	return {
-		type: "lte",
-		key,
-		value
-	};
-}
-/**
-* Creates a not predicate
-* @param key - The key to compare
-* @returns The not predicate
-*
-* @example
-* const predicate = not("name")
-* // result = { type: "not", key: "name", value: "" }
-*/
-function not(key) {
-	return {
-		type: "not",
-		key,
-		value: ""
-	};
-}
-
-//#endregion
-export { BaseQueryBuilder, QueryBuilder, QueryResult, SelectQueryBuilder, and, asc, desc, eq, gt, gte, lt, lte, neq, not, or, selectionToIncludeData };
-//# sourceMappingURL=index.js.map
+export { InvalidPredicateError, MAX_LIMIT, QueryError, QueryResult, SelectQueryBuilder, UnsupportedOperatorError, and, eq, exists, gt, gte, hasType, lt, lte, ne, not, or, render, runQuery, startsWith, toRpcSelect };