@edgestore/shared 0.1.5-alpha.14 → 0.1.5-alpha.16

package/src/internals/providerTypes.ts

@@ -0,0 +1,140 @@
+import { type MaybePromise } from '../types';
+import {
+  type AnyBuilder,
+  type AnyMetadata,
+  type EdgeStoreRouter,
+} from './bucketBuilder';
+
+export type InitParams = {
+  ctx: any;
+  router: EdgeStoreRouter<any>;
+};
+
+export type InitRes = {
+  token?: string;
+};
+
+export type GetFileParams = {
+  url: string;
+};
+
+export type GetFileRes = {
+  url: string;
+  size: number;
+  uploadedAt: Date;
+  path: {
+    [key: string]: string;
+  };
+  metadata: {
+    [key: string]: string;
+  };
+};
+
+export type RequestUploadParams = {
+  multipart?: {
+    uploadId?: string;
+    parts: number[];
+  };
+  bucketName: string;
+  bucketType: string;
+  fileInfo: {
+    size: number;
+    extension: string;
+    isPublic: boolean;
+    fileName?: string;
+    path: {
+      key: string;
+      value: string;
+    }[];
+    metadata: AnyMetadata;
+    replaceTargetUrl?: string;
+    temporary: boolean;
+  };
+};
+
+export type RequestUploadPartsParams = {
+  multipart: {
+    uploadId: string;
+    parts: number[];
+  };
+  path: string;
+};
+
+export type RequestUploadPartsRes = {
+  multipart: {
+    uploadId: string;
+    parts: {
+      partNumber: number;
+      uploadUrl: string;
+    }[];
+  };
+};
+
+export type CompleteMultipartUploadParams = {
+  uploadId: string;
+  key: string;
+  parts: {
+    partNumber: number;
+    eTag: string;
+  }[];
+};
+
+export type CompleteMultipartUploadRes = {
+  success: boolean;
+};
+
+export type RequestUploadRes =
+  | {
+      uploadUrl: string;
+      accessUrl: string;
+      thumbnailUrl?: string | null;
+    }
+  | {
+      multipart: {
+        key: string;
+        uploadId: string;
+        partSize: number;
+        totalParts: number;
+        parts: {
+          partNumber: number;
+          uploadUrl: string;
+        }[];
+      };
+      accessUrl: string;
+      thumbnailUrl?: string | null;
+    };
+
+export type ConfirmUpload = {
+  bucket: AnyBuilder;
+  url: string;
+};
+
+export type ConfirmUploadRes = {
+  success: boolean;
+};
+
+export type DeleteFileParams = {
+  bucket: AnyBuilder;
+  url: string;
+};
+
+export type DeleteFileRes = {
+  success: boolean;
+};
+
+export type Provider = {
+  init: (params: InitParams) => MaybePromise<InitRes>;
+  getBaseUrl: () => MaybePromise<string>;
+  getFile: (params: GetFileParams) => MaybePromise<GetFileRes>;
+  requestUpload: (
+    params: RequestUploadParams,
+  ) => MaybePromise<RequestUploadRes>;
+  requestUploadParts: (
+    params: RequestUploadPartsParams,
+  ) => MaybePromise<RequestUploadPartsRes>;
+  completeMultipartUpload: (
+    params: CompleteMultipartUploadParams,
+  ) => MaybePromise<CompleteMultipartUploadRes>;
+  confirmUpload: (params: ConfirmUpload) => MaybePromise<ConfirmUploadRes>;
+  deleteFile: (params: DeleteFileParams) => MaybePromise<DeleteFileRes>;
+};

package/src/internals/sharedFuncTypes.ts

@@ -0,0 +1,24 @@
+import { type Simplify } from '../types';
+import { type AnyMetadata } from './bucketBuilder';
+import {
+  type DeleteFileRes,
+  type RequestUploadPartsRes,
+  type RequestUploadRes,
+} from './providerTypes';
+
+export type SharedInitRes = {
+  newCookies: string[];
+  token: string | undefined;
+  baseUrl: string;
+};
+export type SharedRequestUploadRes = Simplify<
+  RequestUploadRes & {
+    size: number;
+    uploadedAt: string;
+    path: Record<string, string>;
+    pathOrder: string[];
+    metadata: AnyMetadata;
+  }
+>;
+export type SharedRequestUploadPartsRes = RequestUploadPartsRes;
+export type SharedDeleteFileRes = DeleteFileRes;

package/src/internals/types.ts

@@ -0,0 +1,29 @@
+export type UploadOptions = {
+  /**
+   * e.g. 'my-file-name.jpg'
+   *
+   * By default, a unique file name will be generated for each upload.
+   * If you want to use a custom file name, you can use this option.
+   * If you use the same file name for multiple uploads, the previous file will be overwritten.
+   * But it might take some time for the CDN cache to be cleared.
+   * So maybe you will keep seeing the old file for a while.
+   *
+   * If you want to replace an existing file immediately leave the `manualFileName` option empty and use the `replaceTargetUrl` option.
+   */
+  manualFileName?: string;
+  /**
+   * Use this to replace an existing file.
+   * It will automatically delete the existing file when the upload is complete.
+   */
+  replaceTargetUrl?: string;
+  /**
+   * If true, the file needs to be confirmed by using the `confirmUpload` function.
+   * If the file is not confirmed within 24 hours, it will be deleted.
+   *
+   * This is useful for pages where the file is uploaded as soon as it is selected,
+   * but the user can leave the page without submitting the form.
+   *
+   * This avoids unnecessary zombie files in the bucket.
+   */
+  temporary?: boolean;
+};

package/src/types.ts

@@ -0,0 +1,148 @@
+/**
+ * @internal
+ */
+export type identity<TType> = TType;
+
+export type InferOptional<TType, TKeys extends keyof TType> = Omit<
+  TType,
+  TKeys
+> &
+  Partial<Pick<TType, TKeys>>;
+
+export type UndefinedKeys<TType> = {
+  [K in keyof TType]: undefined extends TType[K] ? K : never;
+}[keyof TType];
+
+/**
+ * @internal
+ */
+export type FlatOverwrite<TType, TWith> = InferOptional<
+  {
+    [TKey in keyof TType | keyof TWith]: TKey extends keyof TWith
+      ? TWith[TKey]
+      : TKey extends keyof TType
+      ? TType[TKey]
+      : never;
+  },
+  UndefinedKeys<TType> | UndefinedKeys<TWith>
+>;
+
+/**
+ * @internal
+ */
+export type IntersectionError<TKey extends string> =
+  `The property '${TKey}' in your router collides with a built-in method, rename this router or procedure on your backend.`;
+
+/**
+ * @internal
+ */
+export type ProtectedIntersection<TType, TWith> = keyof TType &
+  keyof TWith extends never
+  ? TType & TWith
+  : IntersectionError<string & keyof TType & keyof TWith>;
+
+/**
+ * @public
+ */
+export type Maybe<TType> = TType | null | undefined;
+
+/**
+ * @internal
+ */
+export type ThenArg<TType> = TType extends PromiseLike<infer U>
+  ? ThenArg<U>
+  : TType;
+
+/**
+ * @internal
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+export type Simplify<TType> = TType extends any[] | Date
+  ? TType
+  : { [K in keyof TType]: TType[K] };
+
+/**
+ * @internal
+ */
+export type Prettify<TType> = {
+  [K in keyof TType]: TType[K];
+  // eslint-disable-next-line @typescript-eslint/ban-types
+} & {};
+
+/**
+ * @public
+ */
+export type Dict<TType> = Record<string, TType | undefined>;
+
+/**
+ * @public
+ */
+export type MaybePromise<TType> = Promise<TType> | TType;
+
+/**
+ * @internal
+ *
+ * Creates a "lower-priority" type inference.
+ * https://github.com/microsoft/TypeScript/issues/14829#issuecomment-322267089
+ */
+export type InferLast<TType> = TType & {
+  [KeyType in keyof TType]: TType[KeyType];
+};
+
+/**
+ * @public
+ */
+export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
+  ThenArg<ReturnType<TFunction>>;
+
+export type FilterKeys<TObj extends object, TFilter> = {
+  [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
+
+/**
+ * @internal
+ */
+export type Filter<TObj extends object, TFilter> = Pick<
+  TObj,
+  FilterKeys<TObj, TFilter>
+>;
+
+/**
+ * Unwrap return type if the type is a function (sync or async), else use the type as is
+ * @internal
+ */
+export type Unwrap<TType> = TType extends (...args: any[]) => infer R
+  ? ThenArg<R>
+  : TType;
+
+/**
+ * Makes the object recursively optional.
+ * @internal
+ */
+export type DeepPartial<TObject> = TObject extends object
+  ? {
+      [P in keyof TObject]?: DeepPartial<TObject[P]>;
+    }
+  : TObject;
+
+/**
+ * Get the keys of a union type.
+ * @internal
+ */
+export type KeysOfUnion<TUnion> = TUnion extends TUnion
+  ? keyof TUnion extends string
+    ? keyof TUnion
+    : string
+  : never;
+
+/**
+ * Unify a union of objects into a single object.
+ * @internal
+ */
+export type UnifyUnion<TUnion> = Simplify<
+  (TUnion extends any ? (k: TUnion) => void : never) extends (
+    k: infer I,
+  ) => void
+    ? I
+    : never
+>;