@edgestore/server 0.0.0-alpha.12 → 0.0.0-alpha.14

package/src/core/internals/bucketBuilder.ts

@@ -10,10 +10,6 @@ type Merge<TType, TWith> = {
     : TWith[TKey & keyof TWith];
 };
 
-type OverwriteIfDefined<TType, TWith> = UnsetMarker extends TType
-  ? TWith
-  : Simplify<TType & TWith>;
-
 type ConvertStringToFunction<TType> = {
   [K in keyof TType]: TType[K] extends object
     ? Simplify<ConvertStringToFunction<TType[K]>>
@@ -33,23 +29,33 @@ type InferBucketPathKeysFromDef<TDef extends AnyDef> = KeysOfUnion<
   TDef['path'][number]
 >;
 
+export type InferBucketPathObject<TBucket extends Builder<any, AnyDef>> =
+  InferBucketPathKeys<TBucket> extends never
+    ? Record<string, never>
+    : {
+        [TKey in InferBucketPathKeys<TBucket>]: string;
+      };
+
+export type InferBucketPathObjectFromDef<TDef extends AnyDef> =
+  InferBucketPathKeysFromDef<TDef> extends never
+    ? Record<string, never>
+    : {
+        [TKey in InferBucketPathKeysFromDef<TDef>]: string;
+      };
+
 export type InferMetadataObject<TBucket extends Builder<any, AnyDef>> =
   TBucket['_def']['metadata'] extends (...args: any) => any
     ? Awaited<ReturnType<TBucket['_def']['metadata']>>
-    : TBucket['_def']['metadata'] extends ((...args: any) => any) | undefined
-    ? any
-    : never;
+    : Record<string, never>;
 
 type InferMetadataObjectFromDef<TDef extends AnyDef> =
   TDef['metadata'] extends (...args: any) => any
     ? Awaited<ReturnType<TDef['metadata']>>
-    : TDef['metadata'] extends ((...args: any) => any) | undefined
-    ? any
-    : never;
+    : Record<string, never>;
 
 export type AnyContext = Record<string, string | undefined | null>;
 
-export type AnyInput = z.AnyZodObject;
+export type AnyInput = z.AnyZodObject | z.ZodNever;
 
 export type AnyPath = Record<string, () => string>[];
 
@@ -57,10 +63,6 @@ type PathParam<TPath extends AnyPath> = {
   path: keyof UnionToIntersection<TPath[number]>;
 };
 
-const unsetMarker = Symbol('unsetMarker');
-
-type UnsetMarker = typeof unsetMarker;
-
 type Conditions<TPath extends AnyPath> = {
   eq?: string | PathParam<TPath>;
   lt?: string | PathParam<TPath>;
@@ -86,10 +88,30 @@ export type AccessControlSchema<TCtx, TDef extends AnyDef> = Merge<
   }
 >;
 
+type BucketConfig = {
+  /**
+   * Maximum size for a single file in bytes
+   *
+   * e.g. 1024 * 1024 * 10 = 10MB
+   */
+  maxSize?: number;
+  /**
+   * Accepted MIME types
+   *
+   * e.g. ['image/jpeg', 'image/png']
+   *
+   * You can also use wildcards after the slash:
+   *
+   * e.g. ['image/*']
+   */
+  accept?: string[];
+};
+
 type FileInfo = {
   size: number;
   type: string;
   extension: string;
+  fileName?: string;
   replaceTargetUrl?: string;
 };
 
@@ -101,41 +123,43 @@ type BeforeUploadFn<TCtx, TDef extends AnyDef> = (params: {
 
 type BeforeDeleteFn<TCtx, TDef extends AnyDef> = (params: {
   ctx: TCtx;
-  file: {
+  fileInfo: {
     url: string;
     size: number;
     uploadedAt: Date;
-    path: {
-      [TKey in InferBucketPathKeysFromDef<TDef>]: string;
-    };
+    path: InferBucketPathObjectFromDef<TDef>;
     metadata: InferMetadataObjectFromDef<TDef>;
   };
 }) => MaybePromise<boolean>;
 
-type AnyMetadata = Record<string, string | undefined | null>;
+export type AnyMetadata = Record<string, string | undefined | null>;
 
 type MetadataFn<
   TCtx,
-  TDef extends AnyDef,
+  TInput extends AnyInput,
   TMetadata extends AnyMetadata,
-> = (params: {
-  ctx: TCtx;
-  input: z.infer<TDef['input']>;
-}) => MaybePromise<TMetadata>;
+> = (params: { ctx: TCtx; input: z.infer<TInput> }) => MaybePromise<TMetadata>;
+
+export type AnyMetadataFn = MetadataFn<any, AnyInput, AnyMetadata>;
 
 type BucketType = 'IMAGE' | 'FILE';
 
-type Def<TInput extends AnyInput, TPath extends AnyPath> = {
-  type: any;
+type Def<
+  TInput extends AnyInput,
+  TPath extends AnyPath,
+  TMetadata extends AnyMetadataFn,
+> = {
+  type: BucketType;
   input: TInput;
   path: TPath;
-  metadata?: MetadataFn<any, any, any>;
+  metadata: TMetadata;
+  bucketConfig?: BucketConfig;
   accessControl?: AccessControlSchema<any, any>;
   beforeUpload?: BeforeUploadFn<any, any>;
   beforeDelete?: BeforeDeleteFn<any, any>;
 };
 
-type AnyDef = Def<any, any>;
+type AnyDef = Def<AnyInput, AnyPath, AnyMetadataFn>;
 
 type Builder<TCtx, TDef extends AnyDef> = {
   /** only used for types */
@@ -146,20 +170,38 @@ type Builder<TCtx, TDef extends AnyDef> = {
    * @internal
    */
   _def: TDef;
+  /**
+   * You can set an input that will be required in every upload from the client.
+   *
+   * This can be used to add additional information to the file, like choose the file path or add metadata.
+   */
   input<TInput extends AnyInput>(
     input: TInput,
   ): Builder<
     TCtx,
     {
       type: TDef['type'];
-      input: OverwriteIfDefined<TDef['input'], TInput>;
+      input: TInput;
       path: TDef['path'];
       metadata: TDef['metadata'];
+      bucketConfig: TDef['bucketConfig'];
       accessControl: TDef['accessControl'];
       beforeUpload: TDef['beforeUpload'];
       beforeDelete: TDef['beforeDelete'];
     }
   >;
+  /**
+   * The `path` is similar to folders in a file system.
+   * But in this case, every segment of the path must have a meaning.
+   *
+   * ```
+   * // e.g. 123/profile/file.jpg
+   * {
+   *   author: '123',
+   *   type: 'profile',
+   * }
+   * ```
+   */
   path<TParams extends AnyPath>(
     pathResolver: (params: {
       ctx: Simplify<ConvertStringToFunction<TCtx>>;
@@ -172,13 +214,19 @@ type Builder<TCtx, TDef extends AnyDef> = {
       input: TDef['input'];
       path: TParams;
       metadata: TDef['metadata'];
+      bucketConfig: TDef['bucketConfig'];
       accessControl: TDef['accessControl'];
       beforeUpload: TDef['beforeUpload'];
       beforeDelete: TDef['beforeDelete'];
     }
   >;
+  /**
+   * This metadata will be added to every file uploaded to this bucket.
+   *
+   * This can be used, for example, to filter files.
+   */
   metadata<TMetadata extends AnyMetadata>(
-    metadata: MetadataFn<TCtx, TDef, TMetadata>,
+    metadata: MetadataFn<TCtx, TDef['input'], TMetadata>,
   ): Builder<
     TCtx,
     {
@@ -186,11 +234,18 @@ type Builder<TCtx, TDef extends AnyDef> = {
       input: TDef['input'];
       path: TDef['path'];
       metadata: MetadataFn<any, any, TMetadata>;
+      bucketConfig: TDef['bucketConfig'];
       accessControl: TDef['accessControl'];
       beforeUpload: TDef['beforeUpload'];
       beforeDelete: TDef['beforeDelete'];
     }
   >;
+  /**
+   * If you set this, your bucket will automatically be configured as a protected bucket.
+   *
+   * This means that images will only be accessible from within your app.
+   * And only if it passes the check set in this function.
+   */
   accessControl(accessControl: AccessControlSchema<TCtx, TDef>): Builder<
     TCtx,
     {
@@ -198,11 +253,17 @@ type Builder<TCtx, TDef extends AnyDef> = {
       input: TDef['input'];
       path: TDef['path'];
       metadata: TDef['metadata'];
+      bucketConfig: TDef['bucketConfig'];
       accessControl: AccessControlSchema<any, any>;
       beforeUpload: TDef['beforeUpload'];
       beforeDelete: TDef['beforeDelete'];
     }
   >;
+  /**
+   * return `true` to allow upload
+   *
+   * By default every upload from your app is allowed.
+   */
   beforeUpload(beforeUpload: BeforeUploadFn<TCtx, TDef>): Builder<
     TCtx,
     {
@@ -210,11 +271,17 @@ type Builder<TCtx, TDef extends AnyDef> = {
       input: TDef['input'];
       path: TDef['path'];
       metadata: TDef['metadata'];
+      bucketConfig: TDef['bucketConfig'];
       accessControl: TDef['accessControl'];
       beforeUpload: BeforeUploadFn<any, any>;
       beforeDelete: TDef['beforeDelete'];
     }
   >;
+  /**
+   * return `true` to allow delete
+   *
+   * This function must be defined if you want to delete files directly from the client.
+   */
   beforeDelete(beforeDelete: BeforeDeleteFn<TCtx, TDef>): Builder<
     TCtx,
     {
@@ -222,6 +289,7 @@ type Builder<TCtx, TDef extends AnyDef> = {
       input: TDef['input'];
       path: TDef['path'];
       metadata: TDef['metadata'];
+      bucketConfig: TDef['bucketConfig'];
       accessControl: TDef['accessControl'];
       beforeUpload: TDef['beforeUpload'];
       beforeDelete: BeforeDeleteFn<any, any>;
@@ -244,16 +312,23 @@ const createNewBuilder = (initDef: AnyDef, newDef: Partial<AnyDef>) => {
   );
 };
 
-function createBuilder<TCtx, TType extends BucketType>(
+function createBuilder<
+  TCtx,
+  TType extends BucketType,
+  TInput extends AnyInput = z.ZodNever,
+  TPath extends AnyPath = [],
+  TMetadata extends AnyMetadataFn = () => Record<string, never>,
+>(
   opts: { type: TType },
   initDef?: Partial<AnyDef>,
 ): Builder<
   TCtx,
   {
     type: TType;
-    input: UnsetMarker;
-    path: UnsetMarker;
-    metadata?: MetadataFn<any, any, any>;
+    input: TInput;
+    path: TPath;
+    metadata: TMetadata;
+    bucketConfig?: BucketConfig;
     accessControl?: AccessControlSchema<any, any>;
     beforeUpload?: BeforeUploadFn<any, any>;
     beforeDelete?: BeforeDeleteFn<any, any>;
@@ -263,6 +338,7 @@ function createBuilder<TCtx, TType extends BucketType>(
     type: opts.type,
     input: z.never(),
     path: [],
+    metadata: () => ({}),
     ...initDef,
   };
 
@@ -270,6 +346,7 @@ function createBuilder<TCtx, TType extends BucketType>(
     $config: {
       ctx: undefined as TCtx,
     },
+    // @ts-expect-error - I think it would be too much work to make this type correct.
     _def,
     input(input) {
       return createNewBuilder(_def, {
@@ -309,7 +386,7 @@ function createBuilder<TCtx, TType extends BucketType>(
   };
 }
 
-class EdgeStoreBuilder<TCtx = object> {
+class EdgeStoreBuilder<TCtx = Record<string, never>> {
   context<TNewContext extends AnyContext>() {
     return new EdgeStoreBuilder<TNewContext>();
   }
@@ -343,17 +420,28 @@ function createRouterFactory<TCtx>() {
   };
 }
 
+function initBucket<TCtx, TType extends BucketType>(
+  type: TType,
+  config?: BucketConfig,
+) {
+  return createBuilder<TCtx, TType>({ type }, { bucketConfig: config });
+}
+
 function createEdgeStoreInner<TCtx>() {
   return function initEdgeStoreInner() {
     return {
       /**
        * Builder object for creating an image bucket
        */
-      imageBucket: createBuilder<TCtx, 'IMAGE'>({ type: 'IMAGE' }),
+      imageBucket(config?: BucketConfig) {
+        return initBucket<TCtx, 'IMAGE'>('IMAGE', config);
+      },
       /**
        * Builder object for creating a file bucket
        */
-      fileBucket: createBuilder<TCtx, 'FILE'>({ type: 'FILE' }),
+      fileBucket(config?: BucketConfig) {
+        return initBucket<TCtx, 'FILE'>('FILE', config);
+      },
       /**
        * Create a router
        */
@@ -376,7 +464,7 @@ export const initEdgeStore = new EdgeStoreBuilder();
 
 // const es = initEdgeStore.context<Context>().create();
 
-// const imagesBucket = es.imageBucket
+// const imagesBucket = es.imageBucket()
 //   .input(
 //     z.object({
 //       type: z.enum(['profile', 'post']),
@@ -391,7 +479,7 @@ export const initEdgeStore = new EdgeStoreBuilder();
 //   .beforeUpload(() => {
 //     return true;
 //   });
-// const a = es.imageBucket
+// const a = es.imageBucket()
 //   .input(z.object({ type: z.string(), someMeta: z.string().optional() }))
 //   .path(({ ctx, input }) => [{ author: ctx.userId }, { type: input.type }])
 //   .metadata(({ ctx, input }) => ({
@@ -415,7 +503,7 @@ export const initEdgeStore = new EdgeStoreBuilder();
 //     return true;
 //   });
 
-// const b = es.imageBucket.path(({ ctx }) => [{ author: ctx.userId }]);
+// const b = es.imageBucket().path(({ ctx }) => [{ author: ctx.userId }]);
 
 // const router = es.router({
 //   original: imagesBucket,

package/src/core/sdk/index.ts

@@ -1,21 +1,21 @@
 import { AnyRouter } from '..';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
-import { AnyContext } from '../internals/bucketBuilder';
+import { AnyContext, AnyMetadata } from '../internals/bucketBuilder';
 
 const API_ENDPOINT =
-  process.env.EDGE_STORE_API_ENDPOINT ?? 'https://api.edge-store.com';
+  process.env.EDGE_STORE_API_ENDPOINT ?? 'https://api.edgestore.dev';
 
 type FileInfoForUpload = {
   size: number;
   extension: string;
+  type?: string;
   isPublic: boolean;
   path: {
     key: string;
     value: string;
   }[];
-  metadata?: {
-    [key: string]: string;
-  };
+  metadata: AnyMetadata;
+  fileName?: string;
   replaceTargetUrl?: string;
 };
 
@@ -74,7 +74,7 @@ async function makeRequest<TOutput>(params: {
     },
   });
   if (!res.ok) {
-    throw new Error(`Failed to make request to ${path}`);
+    throw new Error(`Failed to make request to ${path}: ${await res.text()}`);
   }
   return (await res.json()) as TOutput;
 }
@@ -182,7 +182,9 @@ export const edgeStoreRawSdk = {
         path: fileInfo.path,
         extension: fileInfo.extension,
         size: fileInfo.size,
+        mimeType: fileInfo.type,
         metadata: fileInfo.metadata,
+        fileName: fileInfo.fileName,
         replaceTargetUrl: fileInfo.replaceTargetUrl,
       },
     });

package/src/providers/edgestore/index.ts

@@ -2,13 +2,11 @@ import { initEdgeStoreSdk } from '../../core/sdk';
 import EdgeStoreCredentialsError from '../../libs/errors/EdgeStoreCredentialsError';
 import { Provider, RequestUploadRes } from '../types';
 
-const DEFAULT_BASE_URL =
-  process.env.EDGE_STORE_BASE_URL ?? 'https://files.edge-store.com';
+const DEFAULT_BASE_URL = 'https://files.edgestore.dev';
 
 export type EdgeStoreProviderOptions = {
   accessKey?: string;
   secretKey?: string;
-  baseUrl?: string;
 };
 
 export function EdgeStoreProvider(
@@ -17,9 +15,10 @@ export function EdgeStoreProvider(
   const {
     accessKey = process.env.EDGE_STORE_ACCESS_KEY,
     secretKey = process.env.EDGE_STORE_SECRET_KEY,
-    baseUrl = process.env.EDGE_STORE_BASE_URL ?? DEFAULT_BASE_URL,
   } = options ?? {};
 
+  const baseUrl = process.env.EDGE_STORE_BASE_URL ?? DEFAULT_BASE_URL;
+
   if (!accessKey || !secretKey) {
     throw new EdgeStoreCredentialsError();
   }

package/src/providers/types.ts

@@ -1,4 +1,8 @@
-import { AnyBuilder, EdgeStoreRouter } from '../core/internals/bucketBuilder';
+import {
+  AnyBuilder,
+  AnyMetadata,
+  EdgeStoreRouter,
+} from '../core/internals/bucketBuilder';
 import { MaybePromise } from '../types';
 
 export type InitParams = {
@@ -41,9 +45,7 @@ export type RequestUploadParams = {
       key: string;
       value: string;
     }[];
-    metadata?: {
-      [key: string]: string;
-    };
+    metadata: AnyMetadata;
     replaceTargetUrl?: string;
   };
 };