@dimah-s3/server 0.7.4 → 0.8.1

package/dist/api/context.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedDimahS3Config } from "../types";
+/**
+ * Injected on every {@link createS3Endpoint} via better-call `routerContext`
+ * (HTTP) and {@link bindEndpoints} (direct `s3.api` calls).
+ */
+export type S3EndpointContext = {
+    config: ResolvedDimahS3Config;
+    request: Request;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/api/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/api/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,qBAAqB,CAAC;IAC9B,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC"}

package/dist/api/create-s3-endpoint.d.ts

@@ -0,0 +1,141 @@
+import { type EndpointOptions } from "better-call";
+declare const createEndpointWithContext: {
+    <Path extends string, Opts extends EndpointOptions, R>(path: Path, options: Opts, handler: import("better-call").EndpointHandler<Path, Opts, R, {
+        config: import("..").ResolvedDimahS3Config;
+        request: Request;
+    }>): import("better-call").StrictEndpoint<Path, ("use" | Exclude<keyof Opts, "body" | "error" | "method" | "query"> extends infer T extends keyof (Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    }) ? { [P in T]: (Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    })[P]; } : never) & (Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_1 ? T_1 extends Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_1 extends {
+        method: ("POST" | "PUT" | "DELETE" | "PATCH" | "GET" | "HEAD")[];
+        body?: import("better-call").StandardSchemaV1<infer B>;
+    } ? T_1 extends {
+        method: infer M;
+        body?: import("better-call").StandardSchemaV1<B>;
+    } ? {
+        method: M;
+        body: import("better-call").StandardSchemaV1<B>;
+    } : never : T_1 extends {
+        method: "POST" | "PUT" | "DELETE" | "PATCH" | ("POST" | "PUT" | "DELETE" | "PATCH")[];
+        body?: import("better-call").StandardSchemaV1<infer B_1>;
+    } ? T_1 extends {
+        method: infer M_1;
+        body?: import("better-call").StandardSchemaV1<B_1>;
+    } ? {
+        method: M_1;
+        body: import("better-call").StandardSchemaV1<B_1>;
+    } : never : T_1 extends {
+        method: "*";
+        body?: import("better-call").StandardSchemaV1<infer B_2>;
+    } ? {
+        method: "*";
+        body?: import("better-call").StandardSchemaV1<B_2>;
+    } : T_1 extends {
+        method: "GET" | "HEAD" | ("GET" | "HEAD")[];
+        body?: never;
+    } ? T_1 extends {
+        method: infer M_2;
+    } ? {
+        method: M_2;
+    } : never : never : never : never) & (Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_2 ? T_2 extends Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_2 extends {
+        query?: import("better-call").StandardSchemaV1<infer Q>;
+    } ? {
+        query: import("better-call").StandardSchemaV1<Q>;
+    } : {} : never : never) & (Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_3 ? T_3 extends Opts & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_3 extends {
+        error?: import("better-call").StandardSchemaV1<infer Err>;
+    } ? {
+        error: import("better-call").StandardSchemaV1<Err>;
+    } : {} : never : never), R>;
+    <Opts_1 extends EndpointOptions, R_1>(options: Opts_1, handler: (context: import("better-call").EndpointContext<string, Opts_1, {
+        config: import("..").ResolvedDimahS3Config;
+        request: Request;
+    }, Record<string, string | undefined> | undefined>) => Promise<R_1>): import("better-call").StrictEndpoint<never, ("use" | Exclude<keyof Opts_1, "body" | "error" | "method" | "query"> extends infer T extends keyof (Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    }) ? { [P in T]: (Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    })[P]; } : never) & (Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_1 ? T_1 extends Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_1 extends {
+        method: ("POST" | "PUT" | "DELETE" | "PATCH" | "GET" | "HEAD")[];
+        body?: import("better-call").StandardSchemaV1<infer B>;
+    } ? T_1 extends {
+        method: infer M;
+        body?: import("better-call").StandardSchemaV1<B>;
+    } ? {
+        method: M;
+        body: import("better-call").StandardSchemaV1<B>;
+    } : never : T_1 extends {
+        method: "POST" | "PUT" | "DELETE" | "PATCH" | ("POST" | "PUT" | "DELETE" | "PATCH")[];
+        body?: import("better-call").StandardSchemaV1<infer B_1>;
+    } ? T_1 extends {
+        method: infer M_1;
+        body?: import("better-call").StandardSchemaV1<B_1>;
+    } ? {
+        method: M_1;
+        body: import("better-call").StandardSchemaV1<B_1>;
+    } : never : T_1 extends {
+        method: "*";
+        body?: import("better-call").StandardSchemaV1<infer B_2>;
+    } ? {
+        method: "*";
+        body?: import("better-call").StandardSchemaV1<B_2>;
+    } : T_1 extends {
+        method: "GET" | "HEAD" | ("GET" | "HEAD")[];
+        body?: never;
+    } ? T_1 extends {
+        method: infer M_2;
+    } ? {
+        method: M_2;
+    } : never : never : never : never) & (Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_2 ? T_2 extends Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_2 extends {
+        query?: import("better-call").StandardSchemaV1<infer Q>;
+    } ? {
+        query: import("better-call").StandardSchemaV1<Q>;
+    } : {} : never : never) & (Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } extends infer T_3 ? T_3 extends Opts_1 & {
+        use: import("better-call").MiddlewareHandler[];
+    } ? T_3 extends {
+        error?: import("better-call").StandardSchemaV1<infer Err>;
+    } ? {
+        error: import("better-call").StandardSchemaV1<Err>;
+    } : {} : never : never), R_1>;
+};
+type CreateS3Endpoint = typeof createEndpointWithContext;
+/**
+ * Typed endpoint for dimah-s3 plugins and core routes.
+ *
+ * Paths are absolute under `basePath` (e.g. `/db/objects`). Context
+ * (`config`, `request`) is injected by the router / `s3.api`.
+ * Zod failures throw `DimahS3Error` (`VALIDATION_ERROR`) via
+ * better-call `onValidationError`.
+ *
+ * ```ts
+ * endpoints: {
+ *   recent: createS3Endpoint("/audit/recent", { method: "GET" }, async (ctx) => {
+ *     return { events: [] };
+ *   }),
+ * }
+ * ```
+ */
+export declare const createS3Endpoint: CreateS3Endpoint;
+export {};
+//# sourceMappingURL=create-s3-endpoint.d.ts.map

package/dist/api/create-s3-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-s3-endpoint.d.ts","sourceRoot":"","sources":["../../src/api/create-s3-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAInE,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAE7B,CAAC;AAaH,KAAK,gBAAgB,GAAG,OAAO,yBAAyB,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAgBE,CAAC"}

package/dist/api/create-s3-middleware.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Injects `config` / `request` and runs the global `guard`.
+ * Used by {@link createS3Endpoint} so HTTP and `s3.api` share the same path.
+ */
+export declare const s3ContextMiddleware: import("better-call").Middleware<import("better-call").MiddlewareOptions, <InputCtx extends import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>>(inputContext: InputCtx) => Promise<{
+    config: import("..").ResolvedDimahS3Config;
+    request: Request;
+}>>;
+/**
+ * Middleware factory with dimah-s3 context already applied — same idea as
+ * Better Auth `createAuthMiddleware`.
+ */
+export declare const createS3Middleware: {
+    <Options extends import("better-call").MiddlewareOptions, R>(options: Options, handler: (ctx: import("better-call").MiddlewareContext<Options, {
+        config: import("..").ResolvedDimahS3Config;
+        request: Request;
+    }>) => Promise<R>): import("better-call").Middleware<Options, (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R>>;
+    <Options extends import("better-call").MiddlewareOptions, R_1>(handler: (ctx: import("better-call").MiddlewareContext<Options, {
+        config: import("..").ResolvedDimahS3Config;
+        request: Request;
+    }>) => Promise<R_1>): import("better-call").Middleware<Options, (inputContext: import("better-call").MiddlewareInputContext<Options>) => Promise<R_1>>;
+};
+//# sourceMappingURL=create-s3-middleware.d.ts.map

package/dist/api/create-s3-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-s3-middleware.d.ts","sourceRoot":"","sources":["../../src/api/create-s3-middleware.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;GAmB9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;CAE7B,CAAC"}

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+export { createS3Endpoint } from "./create-s3-endpoint";
+export { createS3Middleware, s3ContextMiddleware, } from "./create-s3-middleware";
+export type { S3EndpointContext } from "./context";
+export { coreEndpoints, CORE_ENDPOINT_NAMES } from "./routes";
+export type { CoreEndpoints } from "./routes";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC"}