@adgytec/adgytec-web-utils 0.0.1 → 0.0.3

package/dist/chunks/upload

@@ -0,0 +1,371 @@
+import r from "zod";
+import { v7 as u } from "uuid";
+import { B as n, A as l } from "./applicationError";
+import { Queue as m } from "@datastructures-js/queue";
+import { d as y } from "./decode";
+import { httpMethods as c, httpReqHeaders as d, httpRequestCredentials as f } from "../constants/index.js";
+import { mediaCodes as p } from "../errorCodes/index.js";
+const w = r.object({
+  presignPut: r.url(),
+  partNumber: r.int().positive().lte(1e4),
+  partSize: r.int().positive().gt(0)
+}), g = r.object({
+  mediaID: r.uuidv7(),
+  uploadType: r.literal("multipart"),
+  multipartPresignPart: r.array(w).nonempty(),
+  multipartSuccessCallback: r.url()
+}), U = r.object({
+  mediaID: r.uuidv7(),
+  uploadType: r.literal("singlepart"),
+  presignPut: r.url(),
+  singlepartSuccessCallback: r.url()
+}), I = r.discriminatedUnion("uploadType", [
+  g,
+  U
+]), C = (a) => ({
+  id: u(),
+  name: a.name,
+  size: a.size,
+  file: a
+}), k = (a) => a.map(C), P = (a) => ({
+  id: a.id,
+  size: a.size,
+  name: a.name
+}), q = (a) => a.map(P), R = (a, t) => {
+  if (a.id !== t.mediaID)
+    throw new n("media item and response id mismatch");
+  return {
+    ...t,
+    file: a.file,
+    size: a.size
+  };
+}, $ = (a, t) => {
+  if (a.length !== t.length)
+    throw new n(
+      `items mismatch: mediaInfos=${a.length}, apiResponses=${t.length}`
+    );
+  const e = new Map(
+    t.map((i) => [i.mediaID, i])
+  );
+  return a.map((i) => {
+    const s = e.get(i.id);
+    if (!s)
+      throw new n(
+        `Could not find a matching API response for media info with id: ${i.id}`
+      );
+    return R(i, s);
+  });
+};
+class S {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  #n;
+  #o;
+  #r;
+  constructor(t, e, i, s) {
+    this.#s = t, this.#t = e, this.#a = [], this.#i = /* @__PURE__ */ new Set(), this.#e = s, this.#n = i, this.#o = !1, this.#r = !1;
+  }
+  get failed() {
+    return this.#o;
+  }
+  fail() {
+    this.#o = !0;
+  }
+  get id() {
+    return this.#s;
+  }
+  get completeURL() {
+    return this.#n;
+  }
+  get blob() {
+    return this.#t;
+  }
+  add(t) {
+    this.contains(t.partNumber) || (this.#a.push(t), this.#i.add(t.partNumber));
+  }
+  contains(t) {
+    return this.#i.has(t);
+  }
+  get list() {
+    return this.#a.slice().sort((t, e) => t.partNumber - e.partNumber);
+  }
+  get canComplete() {
+    return !this.failed && this.#i.size === this.#e;
+  }
+  tryStartComplete() {
+    return this.#r || !this.canComplete ? !1 : (this.#r = !0, !0);
+  }
+  resetComplete() {
+    this.#r = !1;
+  }
+  get totalPartsCount() {
+    return this.#e;
+  }
+  get uploadedPartsCount() {
+    return this.#i.size;
+  }
+}
+class N {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  constructor(t, e, i, s) {
+    this.#s = t, this.#t = e, this.#i = s, this.#a = i, this.#e = !1;
+  }
+  get canComplete() {
+    return this.#e;
+  }
+  allowComplete() {
+    this.#e = !0;
+  }
+  get id() {
+    return this.#s;
+  }
+  get blob() {
+    return this.#t;
+  }
+  get completeURL() {
+    return this.#i;
+  }
+  get uploadURL() {
+    return this.#a;
+  }
+}
+const L = {
+  concurrentUploads: 4,
+  retryLimit: 3
+};
+class z {
+  #s;
+  #t;
+  #a;
+  #i;
+  #e;
+  #n;
+  constructor(t, e, i = L, s) {
+    this.#s = t, this.#t = e, this.#a = i.concurrentUploads, this.#i = i.retryLimit, this.#e = new m(), this.#n = s;
+  }
+  #o(t) {
+    return t < this.#i;
+  }
+  #r(t) {
+    this.#e.enqueue(t);
+  }
+  async init() {
+    this.#t.init(this.#s);
+    const t = /* @__PURE__ */ new Set();
+    for await (const e of this.#m()) {
+      const i = e().finally(() => t.delete(i));
+      t.add(i), t.size >= this.#a && await Promise.race(t);
+    }
+    await Promise.all(t), await this.#f(), this.#t.completed();
+  }
+  async #l(t, e) {
+    return await fetch(t, {
+      method: c.put,
+      body: e
+    });
+  }
+  async #d(t, e = 0) {
+    if (!t.canComplete)
+      try {
+        if (!(await this.#l(
+          t.uploadURL,
+          t.blob
+        )).ok)
+          throw new l(p.singlepartUploadFailed, {
+            mediaID: t.id
+          });
+        t.allowComplete(), await this.#h(t);
+      } catch (i) {
+        this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "singlepart-upload",
+          retryCount: e + 1,
+          singlepartObj: t
+        })) : this.#t.failed(t.id, i);
+      }
+  }
+  async #p(t, e, i = 0) {
+    if (!(t.failed || t.contains(e.partNumber)))
+      try {
+        const s = await this.#l(
+          e.uploadURL,
+          t.blob.slice(e.startByte, e.endByte)
+        );
+        if (!s.ok)
+          throw new l(
+            p.multipartPartUploadFailed,
+            {
+              mediaID: t.id,
+              partNumber: e.partNumber
+            }
+          );
+        const o = s.headers.get("ETag");
+        if (!o)
+          throw new l(p.missingETagValue, {
+            mediaID: t.id,
+            partNumber: e.partNumber
+          });
+        if (t.add({
+          partNumber: e.partNumber,
+          etag: o
+        }), this.#t.multipartPartUploaded(
+          t.id,
+          t.uploadedPartsCount,
+          t.totalPartsCount
+        ), !t.canComplete) return;
+        await this.#u(t);
+      } catch (s) {
+        this.#o(i) ? (this.#t.multipartPartUploadRetrying(
+          t.id,
+          e.partNumber
+        ), this.#r({
+          type: "multipart-part-upload",
+          retryCount: i + 1,
+          multipartObj: t,
+          partInfo: e
+        })) : (t.fail(), this.#t.failed(t.id, s));
+      }
+  }
+  async #c(t, e) {
+    let i, s;
+    e && (i = JSON.stringify({
+      partsInfo: e
+    }), s = {
+      [d.contentType.key]: d.contentType.valueApplicationJSON
+    }), this.#n && (s = s || {}, s[d.userLocale.key] = this.#n);
+    const o = await fetch(t, {
+      method: c.post,
+      body: i,
+      headers: s,
+      credentials: f.include
+    });
+    await y(o);
+  }
+  async #h(t, e = 0) {
+    if (t.canComplete)
+      try {
+        await this.#c(t.completeURL), this.#t.itemUploaded(t.id);
+      } catch (i) {
+        this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "singlepart-complete",
+          retryCount: e + 1,
+          singlepartObj: t
+        })) : this.#t.failed(t.id, i);
+      }
+  }
+  async #u(t, e = 0) {
+    if (t.tryStartComplete())
+      try {
+        await this.#c(
+          t.completeURL,
+          t.list
+        ), this.#t.itemUploaded(t.id);
+      } catch (i) {
+        t.resetComplete(), this.#o(e) ? (this.#t.uploadRetrying(t.id), this.#r({
+          type: "multipart-complete",
+          retryCount: e + 1,
+          multipartObj: t
+        })) : (t.fail(), this.#t.failed(t.id, i));
+      }
+  }
+  async *#m() {
+    for (const t of this.#s) {
+      if (t.uploadType === "singlepart") {
+        const o = new N(
+          t.mediaID,
+          t.file,
+          t.presignPut,
+          t.singlepartSuccessCallback
+        );
+        yield async () => {
+          await this.#d(o);
+        };
+        continue;
+      }
+      const e = new S(
+        t.mediaID,
+        t.file,
+        t.multipartSuccessCallback,
+        t.multipartPresignPart.length
+      );
+      let i = 0, s = 0;
+      for (const o of t.multipartPresignPart) {
+        s += o.partSize;
+        const h = {
+          partNumber: o.partNumber,
+          uploadURL: o.presignPut,
+          startByte: i,
+          endByte: s
+        };
+        yield async () => {
+          await this.#p(e, h);
+        }, i = s;
+      }
+    }
+  }
+  #y(t) {
+    switch (t.type) {
+      case "singlepart-upload":
+        return this.#d(
+          t.singlepartObj,
+          t.retryCount
+        );
+      case "singlepart-complete":
+        return this.#h(
+          t.singlepartObj,
+          t.retryCount
+        );
+      case "multipart-part-upload":
+        return this.#p(
+          t.multipartObj,
+          t.partInfo,
+          t.retryCount
+        );
+      case "multipart-complete":
+        return this.#u(
+          t.multipartObj,
+          t.retryCount
+        );
+      default:
+        const e = t;
+        throw new n(
+          `Unhandled retry task type: ${e.type}`
+        );
+    }
+  }
+  async #f() {
+    const t = /* @__PURE__ */ new Set();
+    for (; !this.#e.isEmpty(); ) {
+      for (; !this.#e.isEmpty(); ) {
+        const e = this.#e.dequeue();
+        let i = this.#y(e).finally(
+          () => t.delete(i)
+        );
+        t.add(i), t.size >= this.#a && await Promise.race(t);
+      }
+      await Promise.all(t);
+    }
+  }
+}
+const x = async (a, t, e, i) => {
+  await D([a], t, e, i);
+}, D = async (a, t, e, i) => {
+  await new z(a, t, e, i).init();
+};
+export {
+  I as U,
+  k as a,
+  R as b,
+  $ as c,
+  q as d,
+  D as e,
+  C as n,
+  P as t,
+  x as u
+};

package/dist/constants/httpRequestCredentials.d.ts

@@ -0,0 +1 @@
+export declare const httpRequestCredentials: Record<string, RequestCredentials>;

package/dist/constants/httpRequestHeaders.d.ts

@@ -0,0 +1,14 @@
+export declare const httpReqHeaders: {
+    readonly contentType: {
+        readonly key: "Content-Type";
+        readonly valueApplicationJSON: "application/json";
+    };
+    readonly authorization: {
+        readonly key: "Authorization";
+        readonly schemeBearer: "Bearer";
+        readonly schemeBasic: "Basic";
+    };
+    readonly userLocale: {
+        readonly key: "x-user-locale";
+    };
+};

package/dist/constants/http_methods.d.ts

@@ -0,0 +1,7 @@
+export declare const httpMethods: {
+    readonly get: "GET";
+    readonly post: "POST";
+    readonly put: "PUT";
+    readonly patch: "PATCH";
+    readonly delete: "DELETE";
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from './http_methods';
+export * from './httpRequestHeaders';
+export * from './httpRequestCredentials';

package/dist/constants/index.js

@@ -0,0 +1,29 @@
+const e = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE"
+}, t = {
+  contentType: {
+    key: "Content-Type",
+    valueApplicationJSON: "application/json"
+  },
+  authorization: {
+    key: "Authorization",
+    schemeBearer: "Bearer",
+    schemeBasic: "Basic"
+  },
+  userLocale: {
+    key: "x-user-locale"
+  }
+}, o = {
+  include: "include",
+  sameOrigin: "same-origin",
+  omit: "omit"
+};
+export {
+  e as httpMethods,
+  t as httpReqHeaders,
+  o as httpRequestCredentials
+};

package/dist/errorCodes/auth.d.ts

@@ -0,0 +1,14 @@
+export declare const authCodes: {
+    readonly invalidApiKey: "invalid-api-key";
+    readonly userNotFound: "user-not-found";
+    readonly jwtNotAcceptable: "jwt-not-acceptable";
+    readonly invalidSignedUrl: "invalid-signed-url";
+    readonly hashMismatch: "hash-mismatch";
+    readonly invalidAuthHeaderValue: "invalid-auth-header-value";
+    readonly unsupportedAuthScheme: "unsupported-auth-scheme";
+    readonly organizationStatusBad: "bad-org-status";
+    readonly userNotExistsInOrganizationManagement: "user-not-exists-in-organization-management";
+    readonly userNotExistInOrganization: "user-not-exists-in-organization";
+    readonly userDisabled: "user-disabled";
+    readonly tokenNotFound: "token-not-found";
+};

package/dist/errorCodes/common.d.ts

@@ -0,0 +1,5 @@
+export declare const commonCodes: {
+    readonly invalidId: "invalid-id";
+    readonly routeNotFound: "route-not-found";
+    readonly methodNotAllowed: "method-not-allowed";
+};

package/dist/errorCodes/form.d.ts

@@ -0,0 +1,28 @@
+export declare const formCodes: {
+    readonly formValidationFailed: "validation-failed";
+};
+export declare const formFieldTypes: {
+    readonly missing: "missing";
+    readonly overflow: "overflow";
+    readonly underflow: "underflow";
+    readonly length: "length";
+    readonly invalid: "invalid";
+    readonly unknown: "unknown";
+};
+export declare const formFieldInvalidTypeCauses: {
+    readonly invalidValue: "invalid-value";
+    readonly invalidEnumValue: "invalid-enum-value";
+    readonly requireHttps: "require-https";
+    readonly missingHost: "missing-host";
+    readonly containsPath: "contains-path";
+    readonly containsQuery: "contains-query";
+    readonly containsFragment: "contains-fragment";
+    readonly absoluteUrl: "absolute-url";
+    readonly nilID: "nil-id";
+    readonly invalidEmail: "invalid-email";
+    readonly missingMxRecords: "missing-mx-records";
+    readonly notDigit: "not-digit";
+    readonly notBase64UrlEncoded: "not-base64-url-encoded";
+    readonly invalidUrl: "invalid-url";
+    readonly nullValue: "null-value";
+};

package/dist/errorCodes/iam.d.ts

@@ -0,0 +1,6 @@
+export declare const iamCodes: {
+    readonly selfPermissionMismatch: "self-permission-mismatch";
+    readonly invalidActor: "invalid-actor";
+    readonly permissionExplicitlyDenied: "permission-explicitly-denied";
+    readonly missingPermission: "missing-permission";
+};

package/dist/errorCodes/index.d.ts

@@ -0,0 +1,8 @@
+export * from './server';
+export * from './form';
+export * from './auth';
+export * from './reqBody';
+export * from './pagination';
+export * from './common';
+export * from './media';
+export * from './iam';

package/dist/errorCodes/index.js

@@ -0,0 +1,84 @@
+const e = {
+  malformedResponseBody: "malformed-response-body",
+  malformedJsonFromServer: "malformed-json-from-server",
+  invalidResponseShape: "invalid-response-shape",
+  unknownServerError: "unknown-server-error",
+  internalServerError: "internal-server-error"
+}, i = {
+  formValidationFailed: "validation-failed"
+}, o = {
+  missing: "missing",
+  overflow: "overflow",
+  underflow: "underflow",
+  length: "length",
+  invalid: "invalid",
+  unknown: "unknown"
+}, n = {
+  invalidValue: "invalid-value",
+  invalidEnumValue: "invalid-enum-value",
+  requireHttps: "require-https",
+  missingHost: "missing-host",
+  containsPath: "contains-path",
+  containsQuery: "contains-query",
+  containsFragment: "contains-fragment",
+  absoluteUrl: "absolute-url",
+  nilID: "nil-id",
+  invalidEmail: "invalid-email",
+  missingMxRecords: "missing-mx-records",
+  notDigit: "not-digit",
+  notBase64UrlEncoded: "not-base64-url-encoded",
+  invalidUrl: "invalid-url",
+  nullValue: "null-value"
+}, a = {
+  invalidApiKey: "invalid-api-key",
+  userNotFound: "user-not-found",
+  jwtNotAcceptable: "jwt-not-acceptable",
+  invalidSignedUrl: "invalid-signed-url",
+  hashMismatch: "hash-mismatch",
+  invalidAuthHeaderValue: "invalid-auth-header-value",
+  unsupportedAuthScheme: "unsupported-auth-scheme",
+  organizationStatusBad: "bad-org-status",
+  userNotExistsInOrganizationManagement: "user-not-exists-in-organization-management",
+  userNotExistInOrganization: "user-not-exists-in-organization",
+  userDisabled: "user-disabled",
+  tokenNotFound: "token-not-found"
+}, t = {
+  invalidRequestBody: "invalid-request-body",
+  unknownFieldInRequestBody: "unknown-field-in-request-body",
+  emptyRequestBody: "empty-request-body",
+  requestBodyTooLarge: "request-body-too-large"
+}, s = {
+  invalidCursorValue: "invalid-cursor-value"
+}, d = {
+  invalidId: "invalid-id",
+  routeNotFound: "route-not-found",
+  methodNotAllowed: "method-not-allowed"
+}, l = {
+  invalidMultipartNumber: "invalid-multipart-upload-part-number",
+  mediaObjectNotFound: "object-not-found",
+  mediaTooLarge: "media-too-large",
+  mediaItemsLimitExceeded: "media-items-limit-exceeded",
+  uploadAlreadyCompleted: "upload-already-completed",
+  unsupportedObjectUploaded: "unsupported-object-uploaded",
+  completeMultipartUploadCalledTooSoon: "complete-multipart-upload-called-too-soon",
+  singlepartUploadFailed: "singlepart-upload-failed",
+  multipartPartUploadFailed: "multipart-part-upload-failed",
+  missingETagValue: "missing-etag-value"
+}, r = {
+  selfPermissionMismatch: "self-permission-mismatch",
+  invalidActor: "invalid-actor",
+  permissionExplicitlyDenied: "permission-explicitly-denied",
+  missingPermission: "missing-permission"
+};
+export {
+  a as authCodes,
+  d as commonCodes,
+  i as formCodes,
+  n as formFieldInvalidTypeCauses,
+  o as formFieldTypes,
+  r as iamCodes,
+  l as mediaCodes,
+  s as paginationCodes,
+  t as requestBodyCodes,
+  e as serverCodes
+};

package/dist/errorCodes/media.d.ts

@@ -0,0 +1,12 @@
+export declare const mediaCodes: {
+    readonly invalidMultipartNumber: "invalid-multipart-upload-part-number";
+    readonly mediaObjectNotFound: "object-not-found";
+    readonly mediaTooLarge: "media-too-large";
+    readonly mediaItemsLimitExceeded: "media-items-limit-exceeded";
+    readonly uploadAlreadyCompleted: "upload-already-completed";
+    readonly unsupportedObjectUploaded: "unsupported-object-uploaded";
+    readonly completeMultipartUploadCalledTooSoon: "complete-multipart-upload-called-too-soon";
+    readonly singlepartUploadFailed: "singlepart-upload-failed";
+    readonly multipartPartUploadFailed: "multipart-part-upload-failed";
+    readonly missingETagValue: "missing-etag-value";
+};

package/dist/errorCodes/pagination.d.ts

@@ -0,0 +1,3 @@
+export declare const paginationCodes: {
+    readonly invalidCursorValue: "invalid-cursor-value";
+};

package/dist/errorCodes/reqBody.d.ts

@@ -0,0 +1,6 @@
+export declare const requestBodyCodes: {
+    readonly invalidRequestBody: "invalid-request-body";
+    readonly unknownFieldInRequestBody: "unknown-field-in-request-body";
+    readonly emptyRequestBody: "empty-request-body";
+    readonly requestBodyTooLarge: "request-body-too-large";
+};

package/dist/errorCodes/server.d.ts

@@ -0,0 +1,7 @@
+export declare const serverCodes: {
+    readonly malformedResponseBody: "malformed-response-body";
+    readonly malformedJsonFromServer: "malformed-json-from-server";
+    readonly invalidResponseShape: "invalid-response-shape";
+    readonly unknownServerError: "unknown-server-error";
+    readonly internalServerError: "internal-server-error";
+};

package/dist/errorSchema/auth.d.ts

@@ -0,0 +1,37 @@
+import { default as z } from 'zod';
+export declare const invalidApiKeySchema: z.ZodObject<{
+    code: z.ZodLiteral<"invalid-api-key">;
+}, z.core.$strip>;
+export declare const userNotFoundSchema: z.ZodObject<{
+    code: z.ZodLiteral<"user-not-found">;
+}, z.core.$strip>;
+export declare const jwtNotAcceptableSchema: z.ZodObject<{
+    code: z.ZodLiteral<"jwt-not-acceptable">;
+}, z.core.$strip>;
+export declare const invalidSignedUrlSchema: z.ZodObject<{
+    code: z.ZodLiteral<"invalid-signed-url">;
+}, z.core.$strip>;
+export declare const hashMismatchSchema: z.ZodObject<{
+    code: z.ZodLiteral<"hash-mismatch">;
+}, z.core.$strip>;
+export declare const invalidAuthHeaderValueSchema: z.ZodObject<{
+    code: z.ZodLiteral<"invalid-auth-header-value">;
+}, z.core.$strip>;
+export declare const unsupportedAuthSchemeSchema: z.ZodObject<{
+    code: z.ZodLiteral<"unsupported-auth-scheme">;
+}, z.core.$strip>;
+export declare const organizationStatusBadSchema: z.ZodObject<{
+    code: z.ZodLiteral<"bad-org-status">;
+}, z.core.$strip>;
+export declare const userNotExistsInOrganizationManagementSchema: z.ZodObject<{
+    code: z.ZodLiteral<"user-not-exists-in-organization-management">;
+}, z.core.$strip>;
+export declare const userNotExistInOrganizationSchema: z.ZodObject<{
+    code: z.ZodLiteral<"user-not-exists-in-organization">;
+}, z.core.$strip>;
+export declare const userDisabledSchema: z.ZodObject<{
+    code: z.ZodLiteral<"user-disabled">;
+}, z.core.$strip>;
+export declare const tokenNotFoundSchema: z.ZodObject<{
+    code: z.ZodLiteral<"token-not-found">;
+}, z.core.$strip>;

package/dist/errorSchema/common.d.ts

@@ -0,0 +1,10 @@
+import { default as z } from 'zod';
+export declare const invalidIDSchema: z.ZodObject<{
+    code: z.ZodLiteral<"invalid-id">;
+}, z.core.$strip>;
+export declare const routeNotFoundSchema: z.ZodObject<{
+    code: z.ZodLiteral<"route-not-found">;
+}, z.core.$strip>;
+export declare const methodNotAllowedSchema: z.ZodObject<{
+    code: z.ZodLiteral<"method-not-allowed">;
+}, z.core.$strip>;

package/dist/errorSchema/form.d.ts

@@ -0,0 +1,14 @@
+import { default as z } from 'zod';
+import { FormFieldError } from './formField';
+export type FieldNode = {
+    key: string;
+    errors: FormFieldError[];
+} | {
+    key: string;
+    children: FieldNode[];
+};
+export declare const formValidationFailedSchema: z.ZodObject<{
+    code: z.ZodLiteral<"validation-failed">;
+    details: z.ZodArray<z.ZodType<FieldNode, unknown, z.core.$ZodTypeInternals<FieldNode, unknown>>>;
+}, z.core.$strip>;
+export type FormValidationFailed = z.infer<typeof formValidationFailedSchema>;