@xyo-network/sdk 2.102.3 → 7.0.2

package/dist/_pkg/diviner-payload-generic/neutral/index.mjs

@@ -0,0 +1,180 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getProtoOf = Object.getPrototypeOf;
+var __reflectGet = Reflect.get;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __superGet = (cls, obj, key) => __reflectGet(__getProtoOf(cls), key, obj);
+
+// src/Diviner.ts
+import {
+  assertEx,
+  filterAs,
+  forget,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadDiviner } from "../../diviner-payload-abstract/neutral/index.mjs";
+import { asPayloadDivinerQueryPayload, PayloadDivinerConfigZod } from "../../diviner-payload-model/neutral/index.mjs";
+import { creatableModule } from "../../module-model/neutral/index.mjs";
+import { PayloadBuilder } from "../../sdk-protocol/neutral/index.mjs";
+import {
+  asSchema
+} from "../../sdk-protocol/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+import * as z from "zod/mini";
+var DEFAULT_INDEX_BATCH_SIZE = 100;
+var DEFAULT_MAX_INDEX_SIZE = 8e3;
+var GenericPayloadDivinerConfigSchema = asSchema("network.xyo.diviner.payload.generic.config", true);
+var GenericPayloadDivinerConfigZod = z.extend(PayloadDivinerConfigZod, {
+  indexes: z.optional(z.array(z.string())),
+  schema: z.literal(GenericPayloadDivinerConfigSchema)
+});
+var isGenericPayloadDivinerConfig = zodIsFactory(GenericPayloadDivinerConfigZod);
+var asGenericPayloadDivinerConfig = zodAsFactory(GenericPayloadDivinerConfigZod, "asGenericPayloadDivinerConfig");
+var toGenericPayloadDivinerConfig = zodToFactory(GenericPayloadDivinerConfigZod, "toGenericPayloadDivinerConfig");
+var GenericPayloadDiviner = class extends PayloadDiviner {
+  indexMaps = {};
+  payloadsWithMeta = [];
+  _archivistInstance;
+  _cursor;
+  _updatePayloadPairsMutex = new Mutex();
+  get indexBatchSize() {
+    return this.config.indexBatchSize ?? DEFAULT_INDEX_BATCH_SIZE;
+  }
+  get indexes() {
+    return ["schema", ...this.config.indexes ?? []];
+  }
+  get maxIndexSize() {
+    return this.config.maxIndexSize ?? DEFAULT_MAX_INDEX_SIZE;
+  }
+  all(order = "desc", cursor) {
+    const payloads = this.payloadsWithMeta.toSorted(PayloadBuilder.compareStorageMeta);
+    if (order === "desc") payloads.reverse();
+    const startIndex = (cursor ? payloads.findIndex((payload) => payload._sequence === cursor) ?? -1 : -1) + 1;
+    return payloads.slice(startIndex);
+  }
+  async archivistInstance(required = false) {
+    if (!this._archivistInstance) {
+      const archivist = await super.archivistInstance();
+      if (required && !archivist) {
+        throw new Error("Failed to find archivist");
+      }
+      archivist?.on("inserted", this.onArchivistInserted);
+      archivist?.on("cleared", this.onArchivistCleared);
+      archivist?.on("deleted", this.onArchivistDeleted);
+      this._archivistInstance = archivist;
+    }
+    return this._archivistInstance;
+  }
+  async clearIndex() {
+    await this._updatePayloadPairsMutex.runExclusive(() => {
+      this._cursor = void 0;
+      this.payloadsWithMeta = [];
+      this.indexMaps = {};
+    });
+  }
+  async divineHandler(payloads) {
+    const filters = filterAs(payloads ?? [], asPayloadDivinerQueryPayload);
+    assertEx(filters.length < 2, () => "Multiple PayloadDivinerQuery payloads may not be specified");
+    const filter = assertEx(filters.shift(), () => "No PayloadDivinerQuery specified");
+    await this.updateIndex();
+    const {
+      schema,
+      schemas,
+      order,
+      limit,
+      cursor,
+      ...props
+    } = filter;
+    let all = this.all(order, cursor);
+    if (all) {
+      if (schemas?.length) all = all.filter((payload) => schemas.includes(payload.schema));
+      if (Object.keys(props).length > 0) {
+        const additionalFilterCriteria = Object.entries(props);
+        for (const [prop, filter2] of additionalFilterCriteria) {
+          const property = prop;
+          all = Array.isArray(filter2) ? all.filter((payload) => filter2.every((value) => {
+            const prop2 = payload?.[property];
+            return Array.isArray(prop2) && prop2.includes?.(value);
+          })) : all.filter((payload) => payload?.[property] === filter2);
+        }
+      }
+      return limit ? all.slice(0, limit) : all;
+    } else {
+      throw new Error('Archivist does not support "all"');
+    }
+  }
+  onArchivistCleared = () => {
+    forget(
+      (async () => {
+        await this.clearIndex();
+        await this.updateIndex();
+      })()
+    );
+  };
+  // we are just rebuilding the entire index at this point on delete since large archivists do not support delete
+  onArchivistDeleted = () => {
+    forget(
+      (async () => {
+        await this.clearIndex();
+        await this.updateIndex();
+      })()
+    );
+  };
+  onArchivistInserted = () => {
+    forget(this.updateIndex());
+  };
+  async stopHandler(_timeout) {
+    await super.stopHandler();
+    const archivist = await this.archivistInstance(true);
+    archivist.off("inserted", this.onArchivistInserted);
+    archivist.off("deleted", this.onArchivistDeleted);
+    archivist.off("cleared", this.onArchivistCleared);
+  }
+  // index any new payloads
+  async updateIndex() {
+    await this._updatePayloadPairsMutex.runExclusive(async () => {
+      const archivist = await this.archivistInstance(true);
+      let newPayloads = await archivist.next({ limit: 100, cursor: this._cursor });
+      while (newPayloads.length > 0) {
+        this._cursor = newPayloads.at(-1)?._sequence;
+        assertEx(this.payloadsWithMeta.length + newPayloads.length <= this.maxIndexSize, () => "maxIndexSize exceeded");
+        this.indexPayloads(newPayloads);
+        newPayloads = await archivist.next({ limit: 100, cursor: this._cursor });
+      }
+    });
+  }
+  indexPayloads(payloads) {
+    this.payloadsWithMeta.push(...payloads);
+    for (const index of this.indexes ?? []) {
+      this.indexMaps[index] = this.indexMaps[index] ?? [];
+      for (const payload of payloads) {
+        this.indexMaps[index].push(payload);
+      }
+    }
+    return assertEx(payloads.at(-1), () => "No payloads to index")._sequence;
+  }
+};
+__publicField(GenericPayloadDiviner, "configSchemas", [...__superGet(GenericPayloadDiviner, GenericPayloadDiviner, "configSchemas"), GenericPayloadDivinerConfigSchema]);
+__publicField(GenericPayloadDiviner, "defaultConfigSchema", GenericPayloadDivinerConfigSchema);
+GenericPayloadDiviner = __decorateClass([
+  creatableModule()
+], GenericPayloadDiviner);
+export {
+  GenericPayloadDiviner,
+  GenericPayloadDivinerConfigSchema,
+  GenericPayloadDivinerConfigZod,
+  asGenericPayloadDivinerConfig,
+  isGenericPayloadDivinerConfig,
+  toGenericPayloadDivinerConfig
+};

package/dist/_pkg/diviner-payload-model/neutral/Config.d.ts

@@ -0,0 +1,23 @@
+import type { EmptyObject, WithAdditional } from '@xylabs/sdk';
+import { zodAsFactory, zodIsFactory, zodToFactory } from '@xylabs/sdk';
+import type { DivinerConfig } from '../../diviner-model/neutral/index.ts';
+import { DivinerConfigZod } from '../../diviner-model/neutral/index.ts';
+import { type Schema } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+export declare const PayloadDivinerConfigSchema: string & {
+    readonly __schema: true;
+};
+export type PayloadDivinerConfigSchema = typeof PayloadDivinerConfigSchema;
+export declare const PayloadDivinerConfigZod: z.ZodMiniObject<Omit<(typeof DivinerConfigZod)['shape'], 'schema'> & {
+    indexBatchSize: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    maxIndexSize: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    schema: z.ZodMiniLiteral<PayloadDivinerConfigSchema>;
+}, z.core.$strip>;
+export type PayloadDivinerConfigBase = z.infer<typeof PayloadDivinerConfigZod>;
+export declare const isPayloadDivinerConfig: ReturnType<typeof zodIsFactory<PayloadDivinerConfigBase>>;
+export declare const asPayloadDivinerConfig: ReturnType<typeof zodAsFactory<PayloadDivinerConfigBase>>;
+export declare const toPayloadDivinerConfig: ReturnType<typeof zodToFactory<PayloadDivinerConfigBase>>;
+export type PayloadDivinerConfig<TAdditional extends EmptyObject | void = void, TSchema extends Schema | void = void> = DivinerConfig<WithAdditional<{
+    indexBatchSize?: number;
+    maxIndexSize?: number;
+}, TAdditional>, TSchema extends void ? Schema : TSchema>;

package/dist/_pkg/diviner-payload-model/neutral/Order.d.ts

@@ -0,0 +1 @@
+export type Order = 'asc' | 'desc';

package/dist/_pkg/diviner-payload-model/neutral/Params.d.ts

@@ -0,0 +1,4 @@
+import type { DivinerParams } from '../../diviner-model/neutral/index.ts';
+import type { AnyConfigSchema } from '../../module-model/neutral/index.ts';
+import type { PayloadDivinerConfig } from './Config.ts';
+export type PayloadDivinerParams<T extends AnyConfigSchema<PayloadDivinerConfig> | void = void> = DivinerParams<T extends AnyConfigSchema<PayloadDivinerConfig> ? T : AnyConfigSchema<PayloadDivinerConfig>>;

package/dist/_pkg/diviner-payload-model/neutral/Predicate.d.ts

@@ -0,0 +1,9 @@
+import type { EmptyObject } from '@xylabs/sdk';
+import type { Schema, Sequence } from '../../sdk-protocol/neutral/index.ts';
+import type { Order } from './Order.ts';
+export type PayloadDivinerPredicate<T extends EmptyObject = EmptyObject> = Partial<{
+    cursor: Sequence;
+    limit: number;
+    order: Order;
+    schemas: Schema[];
+} & T>;

package/dist/_pkg/diviner-payload-model/neutral/Query.d.ts

@@ -0,0 +1,24 @@
+import type { EmptyObject } from '@xylabs/sdk';
+import { zodAsFactory, zodToFactory } from '@xylabs/sdk';
+import type { Query, Schema, Sequence } from '../../sdk-protocol/neutral/index.ts';
+import { QueryFieldsZod } from '../../sdk-protocol/neutral/index.ts';
+import * as z from 'zod/mini';
+import type { PayloadDivinerPredicate } from './Predicate.ts';
+export declare const PayloadDivinerQuerySchema: string & {
+    readonly __schema: true;
+};
+export type PayloadDivinerQuerySchema = typeof PayloadDivinerQuerySchema;
+export declare const PayloadDivinerQueryPayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<PayloadDivinerQuerySchema>;
+} & (typeof QueryFieldsZod)['shape'] & {
+    cursor: z.ZodMiniOptional<z.ZodMiniCustom<Sequence, Sequence>>;
+    limit: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    order: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<'asc'>, z.ZodMiniLiteral<'desc'>]>>;
+    schemas: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniCustom<Schema, Schema>>>;
+}, z.core.$strip>;
+export type PayloadDivinerQueryPayload<T extends EmptyObject = EmptyObject> = Query<{
+    schema: PayloadDivinerQuerySchema;
+} & PayloadDivinerPredicate<T>>;
+export declare const isPayloadDivinerQueryPayload: <T extends EmptyObject = EmptyObject, TInput = unknown>(x?: TInput) => x is PayloadDivinerQueryPayload<T> & TInput;
+export declare const asPayloadDivinerQueryPayload: ReturnType<typeof zodAsFactory<PayloadDivinerQueryPayload>>;
+export declare const toPayloadDivinerQueryPayload: ReturnType<typeof zodToFactory<PayloadDivinerQueryPayload>>;

package/dist/_pkg/diviner-payload-model/neutral/Schema.d.ts

@@ -0,0 +1,4 @@
+export declare const PayloadDivinerSchema: 'network.xyo.diviner.payload' & {
+    readonly __schema: true;
+};
+export type PayloadDivinerSchema = typeof PayloadDivinerSchema;

package/dist/_pkg/diviner-payload-model/neutral/SortDirection.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated use Order instead */
+export type SortDirection = 'asc' | 'desc';

package/dist/_pkg/diviner-payload-model/neutral/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Config.ts';
+export * from './Order.ts';
+export * from './Params.ts';
+export * from './Predicate.ts';
+export * from './Query.ts';
+export * from './Schema.ts';
+export * from './SortDirection.ts';

package/dist/_pkg/diviner-payload-model/neutral/index.mjs

@@ -0,0 +1,62 @@
+// src/Config.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { DivinerConfigZod } from "../../diviner-model/neutral/index.mjs";
+import { asSchema as asSchema2 } from "../../sdk-protocol/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../sdk-protocol/neutral/index.mjs";
+var PayloadDivinerSchema = asSchema("network.xyo.diviner.payload", true);
+
+// src/Config.ts
+var PayloadDivinerConfigSchema = asSchema2(`${PayloadDivinerSchema}.config`, true);
+var PayloadDivinerConfigZod = z.extend(DivinerConfigZod, {
+  indexBatchSize: z.optional(z.number()),
+  maxIndexSize: z.optional(z.number()),
+  schema: z.literal(PayloadDivinerConfigSchema)
+});
+var isPayloadDivinerConfig = zodIsFactory(PayloadDivinerConfigZod);
+var asPayloadDivinerConfig = zodAsFactory(PayloadDivinerConfigZod, "asPayloadDivinerConfig");
+var toPayloadDivinerConfig = zodToFactory(PayloadDivinerConfigZod, "toPayloadDivinerConfig");
+
+// src/Query.ts
+import {
+  zodAsFactory as zodAsFactory2,
+  zodIsFactory as zodIsFactory2,
+  zodToFactory as zodToFactory2
+} from "@xylabs/sdk";
+import {
+  asSchema as asSchema3,
+  PayloadZodOfSchema,
+  QueryFieldsZod
+} from "../../sdk-protocol/neutral/index.mjs";
+import * as z2 from "zod/mini";
+var PayloadDivinerQuerySchema = asSchema3(`${PayloadDivinerSchema}.query`, true);
+var PayloadDivinerQueryPayloadZod = z2.extend(PayloadZodOfSchema(PayloadDivinerQuerySchema), {
+  ...QueryFieldsZod.shape,
+  cursor: z2.optional(z2.custom()),
+  limit: z2.optional(z2.number()),
+  order: z2.optional(z2.union([z2.literal("asc"), z2.literal("desc")])),
+  schemas: z2.optional(z2.array(z2.custom()))
+});
+var isPayloadDivinerQueryPayloadInternal = zodIsFactory2(PayloadDivinerQueryPayloadZod);
+var isPayloadDivinerQueryPayload = (x) => isPayloadDivinerQueryPayloadInternal(x);
+var asPayloadDivinerQueryPayload = zodAsFactory2(PayloadDivinerQueryPayloadZod, "asPayloadDivinerQueryPayload");
+var toPayloadDivinerQueryPayload = zodToFactory2(PayloadDivinerQueryPayloadZod, "toPayloadDivinerQueryPayload");
+export {
+  PayloadDivinerConfigSchema,
+  PayloadDivinerConfigZod,
+  PayloadDivinerQueryPayloadZod,
+  PayloadDivinerQuerySchema,
+  PayloadDivinerSchema,
+  asPayloadDivinerConfig,
+  asPayloadDivinerQueryPayload,
+  isPayloadDivinerConfig,
+  isPayloadDivinerQueryPayload,
+  toPayloadDivinerConfig,
+  toPayloadDivinerQueryPayload
+};

package/dist/_pkg/diviner-wrapper/neutral/DivinerWrapper.d.ts

@@ -0,0 +1,12 @@
+import type { RetryConfig, TypeCheck } from '@xylabs/sdk';
+import type { DivinerConfig, DivinerInstance, DivinerModule, DivinerModuleEventData, DivinerParams } from '../../diviner-model/neutral/index.ts';
+import type { AnyConfigSchema, ModuleQueryResult } from '../../module-model/neutral/index.ts';
+import { ModuleWrapper } from '../../module-wrapper/neutral/index.ts';
+import type { AccountInstance, Payload, WithoutPrivateStorageMeta, WithSources } from '../../sdk-protocol/neutral/index.ts';
+export declare class DivinerWrapper<TWrappedModule extends DivinerModule<DivinerParams>, TIn extends Payload = Payload, TOut extends Payload = Payload> extends ModuleWrapper<TWrappedModule> implements DivinerInstance<TWrappedModule['params'], TIn, TOut> {
+    static readonly instanceIdentityCheck: TypeCheck<DivinerInstance<DivinerParams<AnyConfigSchema<DivinerConfig>>, Payload, Payload, DivinerModuleEventData>>;
+    static readonly moduleIdentityCheck: TypeCheck<DivinerModule<DivinerParams<AnyConfigSchema<DivinerConfig>>, DivinerModuleEventData>>;
+    static readonly requiredQueries: string[];
+    divine(payloads?: TIn[], _retryConfig?: RetryConfig): Promise<WithoutPrivateStorageMeta<WithSources<TOut>>[]>;
+    divineQuery(payloads?: TIn[], account?: AccountInstance, _retryConfig?: RetryConfig): Promise<ModuleQueryResult<TOut>>;
+}

package/dist/_pkg/diviner-wrapper/neutral/index.d.ts

@@ -0,0 +1 @@
+export * from './DivinerWrapper.ts';

package/dist/_pkg/diviner-wrapper/neutral/index.mjs

@@ -0,0 +1,24 @@
+// src/DivinerWrapper.ts
+import {
+  DivinerDivineQuerySchema,
+  isDivinerInstance,
+  isDivinerModule
+} from "../../diviner-model/neutral/index.mjs";
+import { constructableModuleWrapper, ModuleWrapper } from "../../module-wrapper/neutral/index.mjs";
+constructableModuleWrapper();
+var DivinerWrapper = class extends ModuleWrapper {
+  static instanceIdentityCheck = isDivinerInstance;
+  static moduleIdentityCheck = isDivinerModule;
+  static requiredQueries = [DivinerDivineQuerySchema, ...super.requiredQueries];
+  async divine(payloads, _retryConfig) {
+    const queryPayload = { schema: DivinerDivineQuerySchema };
+    return await this.sendQuery(queryPayload, payloads);
+  }
+  async divineQuery(payloads, account, _retryConfig) {
+    const queryPayload = { schema: DivinerDivineQuerySchema };
+    return await this.sendQueryRaw(queryPayload, payloads, account);
+  }
+};
+export {
+  DivinerWrapper
+};

package/dist/_pkg/dns/neutral/DnsRecordType.d.ts

@@ -0,0 +1,15 @@
+export declare const DnsRecordType: {
+    readonly A: 1;
+    readonly AAAA: 28;
+    readonly CAA: 257;
+    readonly CNAME: 5;
+    readonly DNAME: 39;
+    readonly MX: 15;
+    readonly NS: 2;
+    readonly PTR: 12;
+    readonly SOA: 6;
+    readonly SPF: 99;
+    readonly SRV: 33;
+    readonly TXT: 16;
+};
+export type DnsRecordType = typeof DnsRecordType[keyof typeof DnsRecordType];

package/dist/_pkg/dns/neutral/DnsReturnCode.d.ts

@@ -0,0 +1,13 @@
+export declare const DnsReturnCode: {
+    NoError: number;
+    QueryFormatError: number;
+    ServerFailed: number;
+    DomainDoesNotExist: number;
+    NotImplemented: number;
+    Refused: number;
+    NameShouldNotExist: number;
+    RRSetShouldNotExist: number;
+    NotAuthoritative: number;
+    NotInZone: number;
+};
+export type DnsReturnCode = typeof DnsReturnCode[keyof typeof DnsReturnCode];

package/dist/_pkg/dns/neutral/GoogleDnsResult.d.ts

@@ -0,0 +1,16 @@
+import type { DnsReturnCode } from './DnsReturnCode.ts';
+import type { GoogleDnsResultAnswer } from './GoogleDnsResultAnswer.ts';
+import type { GoogleDnsResultQuestion } from './GoogleDnsResultQuestion.ts';
+export interface GoogleDnsResult {
+    AD?: boolean;
+    Answer?: GoogleDnsResultAnswer[];
+    Authority?: GoogleDnsResultAnswer[];
+    CD?: boolean;
+    Comment?: string;
+    Question?: GoogleDnsResultQuestion[];
+    RA?: boolean;
+    RD?: boolean;
+    Status?: DnsReturnCode;
+    TC?: boolean;
+    edns_client_subnet?: string;
+}

package/dist/_pkg/dns/neutral/GoogleDnsResultAnswer.d.ts

@@ -0,0 +1,7 @@
+import type { DnsRecordType } from './DnsRecordType.ts';
+export interface GoogleDnsResultAnswer {
+    TTL?: number;
+    data?: string;
+    name?: string;
+    type?: DnsRecordType;
+}

package/dist/_pkg/dns/neutral/GoogleDnsResultQuestion.d.ts

@@ -0,0 +1,10 @@
+import type { DnsRecordType } from './DnsRecordType.ts';
+export interface GoogleDnsResultQuestion {
+    cd?: boolean;
+    ct?: string;
+    do?: boolean;
+    edns_client_subnet?: string;
+    name?: string;
+    random_padding?: string;
+    type?: DnsRecordType;
+}

package/dist/_pkg/dns/neutral/domainExists.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a domain exists (resolves using DNS)
+ * @param domain - string
+ * @returns boolean
+ */
+declare const domainExists: (domain?: string) => Promise<boolean>;
+export { domainExists };

package/dist/_pkg/dns/neutral/domainResolve.d.ts

@@ -0,0 +1,8 @@
+import { DnsRecordType } from './DnsRecordType.ts';
+/**
+ * Resolves DNS information (resolves using DNS)
+ * @param domain - string
+ * @returns GoogleDnsResult
+ */
+declare const domainResolve: (domain?: string, type?: DnsRecordType) => Promise<import("./GoogleDnsResult.ts").GoogleDnsResult | undefined>;
+export { domainResolve };

package/dist/_pkg/dns/neutral/googleDnsOverHttps.d.ts

@@ -0,0 +1,4 @@
+import { DnsRecordType } from './DnsRecordType.ts';
+import type { GoogleDnsResult } from './GoogleDnsResult.ts';
+declare const googleDnsOverHttps: (name: string, type?: DnsRecordType) => Promise<GoogleDnsResult | undefined>;
+export { googleDnsOverHttps };

package/dist/_pkg/dns/neutral/index.d.ts

@@ -0,0 +1,8 @@
+export * from './DnsRecordType.ts';
+export * from './DnsReturnCode.ts';
+export * from './domainExists.ts';
+export * from './domainResolve.ts';
+export * from './googleDnsOverHttps.ts';
+export * from './GoogleDnsResult.ts';
+export * from './GoogleDnsResultAnswer.ts';
+export * from './GoogleDnsResultQuestion.ts';

package/dist/_pkg/dns/neutral/index.mjs

@@ -0,0 +1,60 @@
+// src/DnsRecordType.ts
+var DnsRecordType = {
+  A: 1,
+  AAAA: 28,
+  CAA: 257,
+  CNAME: 5,
+  DNAME: 39,
+  MX: 15,
+  NS: 2,
+  PTR: 12,
+  SOA: 6,
+  SPF: 99,
+  SRV: 33,
+  TXT: 16
+};
+
+// src/DnsReturnCode.ts
+var DnsReturnCode = {
+  NoError: 0,
+  QueryFormatError: 1,
+  ServerFailed: 2,
+  DomainDoesNotExist: 3,
+  NotImplemented: 4,
+  Refused: 5,
+  NameShouldNotExist: 6,
+  RRSetShouldNotExist: 7,
+  NotAuthoritative: 8,
+  NotInZone: 9
+};
+
+// src/domainResolve.ts
+import { isDefined } from "@xylabs/sdk";
+
+// src/googleDnsOverHttps.ts
+import { fetchJson } from "@xylabs/sdk";
+var googleDnsOverHttps = async (name, type = DnsRecordType.A) => {
+  const response = await fetchJson(`https://dns.google/resolve?name=${name}&type=${type}`);
+  return response.data ?? void 0;
+};
+
+// src/domainResolve.ts
+var domainResolve = async (domain, type = DnsRecordType.A) => {
+  if (isDefined(domain)) {
+    return await googleDnsOverHttps(domain, type);
+  }
+};
+
+// src/domainExists.ts
+var domainExists = async (domain) => {
+  if (domain === void 0) return false;
+  const dnsResult = await domainResolve(domain);
+  return dnsResult?.Status === DnsReturnCode.NoError;
+};
+export {
+  DnsRecordType,
+  DnsReturnCode,
+  domainExists,
+  domainResolve,
+  googleDnsOverHttps
+};