@edkstack/files 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# @bunstack/core
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run src/index.ts
+```
+
+This project was created using `bun init` in bun v1.3.8. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/backend/index.d.ts

@@ -0,0 +1,17 @@
+import { BunSQLDatabase as BunSQLDatabase2 } from "drizzle-orm/bun-sql";
+type Visibility = "private" | "public";
+interface PurposePolicy {
+	maxSize?: number;
+	allowedMimeTypes?: string[];
+	visibility?: Visibility;
+}
+import { S3Client as S3Client2 } from "bun";
+interface FilesBackendOptions<TPurposes extends string> {
+	db: BunSQLDatabase2;
+	client: S3Client2;
+	policies: Record<TPurposes, PurposePolicy>;
+	publicBaseUrl: string;
+	presignExpiresIn?: number;
+}
+declare function createFilesBackend<const TPurpose extends string>(options: FilesBackendOptions<TPurpose>): {};
+export { createFilesBackend, Visibility, PurposePolicy, FilesBackendOptions };

package/dist/backend/index.js

@@ -0,0 +1,204 @@
+// src/backend/routes.ts
+import { Elysia, t } from "elysia";
+function createRoutes(options) {
+  const {
+    services,
+    policies
+  } = options;
+  return new Elysia({
+    prefix: "/api"
+  }).post("/files/upload", async ({ status, body }) => {
+    const { file, purpose } = body;
+    const policy = policies[purpose];
+    if (!policy) {
+      return status(400, {
+        message: "Purpose not supported"
+      });
+    }
+    if (policy.maxSize !== undefined && file.size > policy.maxSize) {
+      return status(400, {
+        message: "File size exceeds the maximum allowed size"
+      });
+    }
+    if (policy.allowedMimeTypes !== undefined && !policy.allowedMimeTypes.includes(file.type)) {
+      return status(400, {
+        message: "File type not allowed"
+      });
+    }
+    const uploaded = await services.uploadFile({
+      file,
+      purpose,
+      visibility: policy.visibility ?? "private"
+    });
+    return status(200, {
+      id: uploaded.id,
+      name: uploaded.name,
+      key: uploaded.key,
+      size: uploaded.size,
+      mimeType: uploaded.mimeType,
+      createdAt: uploaded.createdAt
+    });
+  }, {
+    body: UploadRequest(Object.keys(policies)),
+    response: {
+      200: FileResponse,
+      400: ErrorResponse,
+      500: ErrorResponse
+    }
+  });
+}
+function UploadRequest(purposes) {
+  return t.Object({
+    file: t.File(),
+    purpose: t.Union(purposes.map((p) => t.Literal(p)))
+  });
+}
+var ErrorResponse = t.Object({
+  message: t.String()
+});
+var FileResponse = t.Object({
+  id: t.String(),
+  name: t.Nullable(t.String()),
+  key: t.String(),
+  size: t.Number(),
+  mimeType: t.String(),
+  createdAt: t.Date()
+});
+
+// src/backend/schemas.ts
+import { nanoid } from "nanoid";
+import { index, integer, pgTable, text, timestamp, pgEnum } from "drizzle-orm/pg-core";
+function createSchemas() {
+  const files = pgTable("files", {
+    id: text("id").primaryKey().$defaultFn(() => `file_${nanoid()}`),
+    purpose: text("purpose").notNull(),
+    name: text("name"),
+    key: text("key").notNull().unique(),
+    size: integer("size").notNull(),
+    mimeType: text("mime_type").notNull().default("application/octet-stream"),
+    refCount: integer("ref_count").notNull().default(0),
+    visibility: pgEnum("visibility", ["private", "public"])().notNull().default("private"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow()
+  }, (table) => [
+    index("files_key_idx").on(table.key),
+    index("files_created_at_idx").on(table.createdAt)
+  ]);
+  return {
+    files
+  };
+}
+
+// src/backend/services.ts
+import { nanoid as nanoid2 } from "nanoid";
+import { extname } from "path";
+import { eq, sql, and } from "drizzle-orm";
+function createServices(options) {
+  const {
+    db,
+    schemas,
+    s3Client,
+    publicBaseUrl,
+    keyPrefix = "files",
+    presignExpiresIn = 3600
+  } = options;
+  return {
+    s3Client,
+    async getFile(params) {
+      const [found] = await db.select().from(schemas.files).where(eq(schemas.files.id, params.id)).limit(1);
+      if (!found) {
+        throw new Error("File not found");
+      }
+      return found;
+    },
+    async getUrl(params) {
+      const [found] = await db.select({
+        key: schemas.files.key,
+        visibility: schemas.files.visibility
+      }).from(schemas.files).where(eq(schemas.files.id, params.id)).limit(1);
+      if (!found) {
+        throw new Error("File not found");
+      }
+      if (found.visibility === "public") {
+        return `${publicBaseUrl}/${found.key}`;
+      }
+      return s3Client.presign(found.key, { expiresIn: presignExpiresIn });
+    },
+    async uploadFile(params) {
+      const id = nanoid2();
+      const ext = extname(params.file.name);
+      const key = [keyPrefix, params.visibility, params.purpose, `${id}${ext}`].join("/");
+      const s3file = s3Client.file(key);
+      await s3file.write(params.file, {
+        type: params.file.type,
+        acl: params.visibility === "public" ? "public-read" : "private"
+      });
+      try {
+        const [created] = await db.insert(schemas.files).values({
+          purpose: params.purpose,
+          key,
+          size: s3file.size,
+          name: s3file.name ?? null,
+          mimeType: s3file.type,
+          visibility: params.visibility
+        }).returning();
+        if (!created) {
+          throw new Error("Failed to create file record");
+        }
+        return created;
+      } catch (error) {
+        await s3file.delete().catch();
+        throw error;
+      }
+    },
+    async deleteFile(params) {
+      const [deleted] = await db.delete(schemas.files).where(eq(schemas.files.id, params.id)).returning();
+      if (!deleted)
+        return;
+      await s3Client.delete(deleted.key);
+    },
+    async acquireFile(params) {
+      const [updated] = await db.update(schemas.files).set({ refCount: sql`${schemas.files.refCount} + 1` }).where(and(eq(schemas.files.id, params.id), params.purpose ? eq(schemas.files.purpose, params.purpose) : undefined)).returning();
+      if (!updated) {
+        throw new Error("File not found");
+      }
+      return updated;
+    },
+    async releaseFile(params) {
+      const [updated] = await db.update(schemas.files).set({ refCount: sql`${schemas.files.refCount} - 1` }).where(eq(schemas.files.id, params.id)).returning();
+      if (!updated) {
+        throw new Error("File not found");
+      }
+      if (updated.refCount < 1) {
+        await this.deleteFile({ id: params.id });
+      }
+    }
+  };
+}
+
+// src/backend/backend.ts
+function createFilesBackend(options) {
+  const schemas = createSchemas();
+  const services = createServices({
+    db: options.db,
+    schemas,
+    s3Client: options.client,
+    publicBaseUrl: options.publicBaseUrl,
+    presignExpiresIn: options.presignExpiresIn
+  });
+  const routes = createRoutes({
+    services,
+    policies: options.policies
+  });
+  return {
+    schemas,
+    routes,
+    services
+  };
+}
+export {
+  createFilesBackend
+};
+
+//# debugId=6563BBC77836F87F64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\backend\\routes.ts", "src\\backend\\schemas.ts", "src\\backend\\services.ts", "src\\backend\\backend.ts"],
  "sourcesContent": [
    "import { Elysia, t } from \"elysia\";\r\nimport type { Services } from \"./services\";\r\n\r\nexport type Visibility = \"private\" | \"public\";\r\n\r\nexport interface PurposePolicy {\r\n  maxSize?: number;\r\n  allowedMimeTypes?: string[];\r\n  visibility?: Visibility;\r\n}\r\n\r\nexport function createRoutes<const TPurpose extends string>(\r\n  options: {\r\n    services: Services;\r\n    policies: Record<TPurpose, PurposePolicy>\r\n  }\r\n) {\r\n  \r\n  const { \r\n    services, \r\n    policies,\r\n  } = options;\r\n\r\n  return new Elysia({\r\n    prefix: \"/api\",\r\n  }).post(\"/files/upload\", async ({ status, body }) => {\r\n    const { file, purpose } = body;\r\n    const policy = policies[purpose as TPurpose];\r\n    if (!policy) {\r\n      return status(400, {\r\n        message: \"Purpose not supported\",\r\n      });\r\n    }\r\n    if (policy.maxSize !== undefined && file.size > policy.maxSize) {\r\n      return status(400, {\r\n        message: \"File size exceeds the maximum allowed size\",\r\n      });\r\n    }\r\n    if (policy.allowedMimeTypes !== undefined && !policy.allowedMimeTypes.includes(file.type)) {\r\n      return status(400, {\r\n        message: \"File type not allowed\",\r\n      });\r\n    }\r\n    const uploaded = await services.uploadFile({ \r\n      file, \r\n      purpose, \r\n      visibility: policy.visibility ?? \"private\" \r\n    });\r\n    return status(200, {\r\n      id: uploaded.id,\r\n      name: uploaded.name,\r\n      key: uploaded.key,\r\n      size: uploaded.size,\r\n      mimeType: uploaded.mimeType,\r\n      createdAt: uploaded.createdAt,\r\n    });\r\n  }, {\r\n    body: UploadRequest(Object.keys(policies) as TPurpose[]),\r\n    response: {\r\n      200: FileResponse,\r\n      400: ErrorResponse,\r\n      500: ErrorResponse,\r\n    }\r\n  });\r\n}\r\n\r\nfunction UploadRequest<const TPurpose extends string>(\r\n  purposes: TPurpose[]\r\n) {\r\n  return t.Object({\r\n    file: t.File(),\r\n    purpose: t.Union(\r\n      purposes.map((p) => t.Literal(p)) as [\r\n        ReturnType<typeof t.Literal<TPurpose>>,\r\n        ...ReturnType<typeof t.Literal<TPurpose>>[],\r\n      ]\r\n    )\r\n  });\r\n}\r\n\r\nconst ErrorResponse = t.Object({\r\n  message: t.String(),\r\n});\r\n\r\nconst FileResponse = t.Object({\r\n  id: t.String(),\r\n  name: t.Nullable(t.String()),\r\n  key: t.String(),\r\n  size: t.Number(),\r\n  mimeType: t.String(),\r\n  createdAt: t.Date(),\r\n});",
    "import { nanoid } from \"nanoid\";\r\nimport { index, integer, pgTable, text, timestamp, pgEnum } from \"drizzle-orm/pg-core\";\r\n\r\n\r\nexport type AllSchemas = ReturnType<typeof createSchemas>;\r\nexport type FileSchema = AllSchemas[\"files\"];\r\nexport type FileSelect = FileSchema[\"$inferSelect\"];\r\nexport type FileInsert = FileSchema[\"$inferInsert\"];\r\n\r\nexport function createSchemas() {\r\n\r\n  const files = pgTable(\"files\", {\r\n    id: text(\"id\").primaryKey().$defaultFn(() => `file_${nanoid()}`),\r\n    purpose: text(\"purpose\").notNull(),\r\n    name: text(\"name\"),\r\n    key: text(\"key\").notNull().unique(),\r\n    size: integer(\"size\").notNull(),\r\n    mimeType: text(\"mime_type\").notNull().default(\"application/octet-stream\"),\r\n    refCount: integer(\"ref_count\").notNull().default(0),\r\n    visibility: pgEnum(\"visibility\", [\"private\", \"public\"])().notNull().default(\"private\"),\r\n    createdAt: timestamp(\"created_at\").notNull().defaultNow(),\r\n    updatedAt: timestamp(\"updated_at\").notNull().defaultNow(),\r\n  }, (table) => [\r\n    index(\"files_key_idx\").on(table.key),\r\n    index(\"files_created_at_idx\").on(table.createdAt),\r\n  ]);\r\n\r\n  return {\r\n    files,\r\n  }\r\n}",
    "import type { S3Client, S3File } from \"bun\";\r\nimport { nanoid } from \"nanoid\";\r\nimport { extname } from \"path\";\r\nimport { eq, sql, lt, and } from \"drizzle-orm\";\r\nimport type { BunSQLDatabase } from \"drizzle-orm/bun-sql\";\r\nimport type { AllSchemas, FileSelect } from \"./schemas\";\r\n\r\nexport type Services = ReturnType<typeof createServices>;\r\n\r\ntype ById = { id: string };\r\ntype ByKey = { key: string };\r\n\r\nexport function createServices(\r\n  options: {\r\n    db: BunSQLDatabase;\r\n    schemas: AllSchemas;\r\n    s3Client: S3Client;\r\n    publicBaseUrl: string;\r\n    keyPrefix?: string;\r\n    presignExpiresIn?: number;\r\n  }\r\n) {\r\n  const { \r\n    db, \r\n    schemas, \r\n    s3Client, \r\n    publicBaseUrl, \r\n    keyPrefix = \"files\",\r\n    presignExpiresIn = 3600\r\n  } = options;\r\n  \r\n  return {\r\n\r\n    s3Client,\r\n\r\n    async getFile(params: ById): Promise<FileSelect> {\r\n      const [found] = await db\r\n        .select()\r\n        .from(schemas.files)\r\n        .where(eq(schemas.files.id, params.id))\r\n        .limit(1);\r\n      if (!found) {\r\n        throw new Error(\"File not found\");\r\n      }\r\n      return found;\r\n    },\r\n\r\n    async getUrl(params: ById): Promise<string> {\r\n      const [found] = await db\r\n        .select({ \r\n          key: schemas.files.key,\r\n          visibility: schemas.files.visibility,\r\n        })\r\n        .from(schemas.files)\r\n        .where(eq(schemas.files.id, params.id))\r\n        .limit(1);\r\n      if (!found) {\r\n        throw new Error(\"File not found\");\r\n      }\r\n      if (found.visibility === \"public\") {\r\n        return `${publicBaseUrl}/${found.key}`;\r\n      }\r\n      return s3Client.presign(found.key, { expiresIn: presignExpiresIn });\r\n    },\r\n\r\n    async uploadFile(params: {\r\n      file: File;\r\n      purpose: string;\r\n      visibility: \"private\" | \"public\";\r\n    }): Promise<FileSelect> {\r\n      const id = nanoid();\r\n      const ext = extname(params.file.name);\r\n      const key = [keyPrefix, params.visibility, params.purpose, `${id}${ext}`].join(\"/\");\r\n      const s3file = s3Client.file(key);\r\n      await s3file.write(params.file, {\r\n        type: params.file.type,\r\n        acl: params.visibility === \"public\" ? \"public-read\" : \"private\",\r\n      });\r\n      try {\r\n        const [created] = await db.insert(schemas.files)\r\n          .values({\r\n            purpose: params.purpose,\r\n            key,\r\n            size: s3file.size,\r\n            name: s3file.name ?? null,\r\n            mimeType: s3file.type,\r\n            visibility: params.visibility,\r\n          })\r\n          .returning();\r\n        if (!created) {\r\n          throw new Error(\"Failed to create file record\");\r\n        }\r\n        return created;\r\n      } catch (error) {\r\n        await s3file.delete().catch();\r\n        throw error;\r\n      }\r\n    },\r\n\r\n    async deleteFile(params: { id: string }): Promise<void> {\r\n      const [deleted] = await db\r\n        .delete(schemas.files)\r\n        .where(eq(schemas.files.id, params.id))\r\n        .returning();\r\n      if (!deleted) return;\r\n      await s3Client.delete(deleted.key);\r\n    },\r\n\r\n    async acquireFile(params: ById & { \r\n      purpose?: string \r\n    }): Promise<FileSelect> {\r\n      const [updated] = await db\r\n        .update(schemas.files)\r\n        .set({ refCount: sql`${schemas.files.refCount} + 1` })\r\n        .where(\r\n          and(\r\n            eq(schemas.files.id, params.id),\r\n            params.purpose ? eq(schemas.files.purpose, params.purpose) : undefined,\r\n          )\r\n        )\r\n        .returning();\r\n      if (!updated) {\r\n        throw new Error(\"File not found\");\r\n      }\r\n      return updated;\r\n    },\r\n\r\n    async releaseFile(params: ById): Promise<void> {\r\n      const [updated] = await db\r\n        .update(schemas.files)\r\n        .set({ refCount: sql`${schemas.files.refCount} - 1` })\r\n        .where(eq(schemas.files.id, params.id))\r\n        .returning();\r\n      if (!updated) {\r\n        throw new Error(\"File not found\");\r\n      }\r\n      if (updated.refCount < 1) {\r\n        await this.deleteFile({ id: params.id });\r\n      }\r\n    },\r\n  };\r\n}",
    "import type { BunSQLDatabase } from \"drizzle-orm/bun-sql\";\r\nimport { createRoutes, type PurposePolicy } from \"./routes\";\r\nimport { createSchemas } from \"./schemas\";\r\nimport { createServices } from \"./services\";\r\nimport type { S3Client } from \"bun\";\r\n\r\nexport interface FilesBackendOptions<TPurposes extends string> {\r\n  db: BunSQLDatabase;\r\n  client: S3Client;\r\n  policies: Record<TPurposes, PurposePolicy>;\r\n  publicBaseUrl: string;\r\n  presignExpiresIn?: number;\r\n}\r\n\r\nexport function createFilesBackend<const TPurpose extends string>(\r\n  options: FilesBackendOptions<TPurpose>\r\n) {\r\n  const schemas = createSchemas();\r\n  const services = createServices({\r\n    db: options.db,\r\n    schemas,\r\n    s3Client: options.client,\r\n    publicBaseUrl: options.publicBaseUrl,\r\n    presignExpiresIn: options.presignExpiresIn,\r\n  });\r\n  const routes = createRoutes({\r\n    services,\r\n    policies: options.policies,\r\n  });\r\n  return {\r\n    schemas,\r\n    routes,\r\n    services,\r\n  } as const;\r\n}"
  ],
  "mappings": ";AAAA;AAWO,SAAS,YAA2C,CACzD,SAIA;AAAA,EAEA;AAAA,IACE;AAAA,IACA;AAAA,MACE;AAAA,EAEJ,OAAO,IAAI,OAAO;AAAA,IAChB,QAAQ;AAAA,EACV,CAAC,EAAE,KAAK,iBAAiB,SAAS,QAAQ,WAAW;AAAA,IACnD,QAAQ,MAAM,YAAY;AAAA,IAC1B,MAAM,SAAS,SAAS;AAAA,IACxB,IAAI,CAAC,QAAQ;AAAA,MACX,OAAO,OAAO,KAAK;AAAA,QACjB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,IACA,IAAI,OAAO,YAAY,aAAa,KAAK,OAAO,OAAO,SAAS;AAAA,MAC9D,OAAO,OAAO,KAAK;AAAA,QACjB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,IACA,IAAI,OAAO,qBAAqB,aAAa,CAAC,OAAO,iBAAiB,SAAS,KAAK,IAAI,GAAG;AAAA,MACzF,OAAO,OAAO,KAAK;AAAA,QACjB,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,IACA,MAAM,WAAW,MAAM,SAAS,WAAW;AAAA,MACzC;AAAA,MACA;AAAA,MACA,YAAY,OAAO,cAAc;AAAA,IACnC,CAAC;AAAA,IACD,OAAO,OAAO,KAAK;AAAA,MACjB,IAAI,SAAS;AAAA,MACb,MAAM,SAAS;AAAA,MACf,KAAK,SAAS;AAAA,MACd,MAAM,SAAS;AAAA,MACf,UAAU,SAAS;AAAA,MACnB,WAAW,SAAS;AAAA,IACtB,CAAC;AAAA,KACA;AAAA,IACD,MAAM,cAAc,OAAO,KAAK,QAAQ,CAAe;AAAA,IACvD,UAAU;AAAA,MACR,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF,CAAC;AAAA;AAGH,SAAS,aAA4C,CACnD,UACA;AAAA,EACA,OAAO,EAAE,OAAO;AAAA,IACd,MAAM,EAAE,KAAK;AAAA,IACb,SAAS,EAAE,MACT,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAIlC;AAAA,EACF,CAAC;AAAA;AAGH,IAAM,gBAAgB,EAAE,OAAO;AAAA,EAC7B,SAAS,EAAE,OAAO;AACpB,CAAC;AAED,IAAM,eAAe,EAAE,OAAO;AAAA,EAC5B,IAAI,EAAE,OAAO;AAAA,EACb,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC;AAAA,EAC3B,KAAK,EAAE,OAAO;AAAA,EACd,MAAM,EAAE,OAAO;AAAA,EACf,UAAU,EAAE,OAAO;AAAA,EACnB,WAAW,EAAE,KAAK;AACpB,CAAC;;;AC3FD;AACA;AAQO,SAAS,aAAa,GAAG;AAAA,EAE9B,MAAM,QAAQ,QAAQ,SAAS;AAAA,IAC7B,IAAI,KAAK,IAAI,EAAE,WAAW,EAAE,WAAW,MAAM,QAAQ,OAAO,GAAG;AAAA,IAC/D,SAAS,KAAK,SAAS,EAAE,QAAQ;AAAA,IACjC,MAAM,KAAK,MAAM;AAAA,IACjB,KAAK,KAAK,KAAK,EAAE,QAAQ,EAAE,OAAO;AAAA,IAClC,MAAM,QAAQ,MAAM,EAAE,QAAQ;AAAA,IAC9B,UAAU,KAAK,WAAW,EAAE,QAAQ,EAAE,QAAQ,0BAA0B;AAAA,IACxE,UAAU,QAAQ,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC;AAAA,IAClD,YAAY,OAAO,cAAc,CAAC,WAAW,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,QAAQ,SAAS;AAAA,IACrF,WAAW,UAAU,YAAY,EAAE,QAAQ,EAAE,WAAW;AAAA,IACxD,WAAW,UAAU,YAAY,EAAE,QAAQ,EAAE,WAAW;AAAA,EAC1D,GAAG,CAAC,UAAU;AAAA,IACZ,MAAM,eAAe,EAAE,GAAG,MAAM,GAAG;AAAA,IACnC,MAAM,sBAAsB,EAAE,GAAG,MAAM,SAAS;AAAA,EAClD,CAAC;AAAA,EAED,OAAO;AAAA,IACL;AAAA,EACF;AAAA;;;AC5BF,mBAAS;AACT;AACA;AASO,SAAS,cAAc,CAC5B,SAQA;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,YAAY;AAAA,IACZ,mBAAmB;AAAA,MACjB;AAAA,EAEJ,OAAO;AAAA,IAEL;AAAA,SAEM,QAAO,CAAC,QAAmC;AAAA,MAC/C,OAAO,SAAS,MAAM,GACnB,OAAO,EACP,KAAK,QAAQ,KAAK,EAClB,MAAM,GAAG,QAAQ,MAAM,IAAI,OAAO,EAAE,CAAC,EACrC,MAAM,CAAC;AAAA,MACV,IAAI,CAAC,OAAO;AAAA,QACV,MAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AAAA,MACA,OAAO;AAAA;AAAA,SAGH,OAAM,CAAC,QAA+B;AAAA,MAC1C,OAAO,SAAS,MAAM,GACnB,OAAO;AAAA,QACN,KAAK,QAAQ,MAAM;AAAA,QACnB,YAAY,QAAQ,MAAM;AAAA,MAC5B,CAAC,EACA,KAAK,QAAQ,KAAK,EAClB,MAAM,GAAG,QAAQ,MAAM,IAAI,OAAO,EAAE,CAAC,EACrC,MAAM,CAAC;AAAA,MACV,IAAI,CAAC,OAAO;AAAA,QACV,MAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AAAA,MACA,IAAI,MAAM,eAAe,UAAU;AAAA,QACjC,OAAO,GAAG,iBAAiB,MAAM;AAAA,MACnC;AAAA,MACA,OAAO,SAAS,QAAQ,MAAM,KAAK,EAAE,WAAW,iBAAiB,CAAC;AAAA;AAAA,SAG9D,WAAU,CAAC,QAIO;AAAA,MACtB,MAAM,KAAK,QAAO;AAAA,MAClB,MAAM,MAAM,QAAQ,OAAO,KAAK,IAAI;AAAA,MACpC,MAAM,MAAM,CAAC,WAAW,OAAO,YAAY,OAAO,SAAS,GAAG,KAAK,KAAK,EAAE,KAAK,GAAG;AAAA,MAClF,MAAM,SAAS,SAAS,KAAK,GAAG;AAAA,MAChC,MAAM,OAAO,MAAM,OAAO,MAAM;AAAA,QAC9B,MAAM,OAAO,KAAK;AAAA,QAClB,KAAK,OAAO,eAAe,WAAW,gBAAgB;AAAA,MACxD,CAAC;AAAA,MACD,IAAI;AAAA,QACF,OAAO,WAAW,MAAM,GAAG,OAAO,QAAQ,KAAK,EAC5C,OAAO;AAAA,UACN,SAAS,OAAO;AAAA,UAChB;AAAA,UACA,MAAM,OAAO;AAAA,UACb,MAAM,OAAO,QAAQ;AAAA,UACrB,UAAU,OAAO;AAAA,UACjB,YAAY,OAAO;AAAA,QACrB,CAAC,EACA,UAAU;AAAA,QACb,IAAI,CAAC,SAAS;AAAA,UACZ,MAAM,IAAI,MAAM,8BAA8B;AAAA,QAChD;AAAA,QACA,OAAO;AAAA,QACP,OAAO,OAAO;AAAA,QACd,MAAM,OAAO,OAAO,EAAE,MAAM;AAAA,QAC5B,MAAM;AAAA;AAAA;AAAA,SAIJ,WAAU,CAAC,QAAuC;AAAA,MACtD,OAAO,WAAW,MAAM,GACrB,OAAO,QAAQ,KAAK,EACpB,MAAM,GAAG,QAAQ,MAAM,IAAI,OAAO,EAAE,CAAC,EACrC,UAAU;AAAA,MACb,IAAI,CAAC;AAAA,QAAS;AAAA,MACd,MAAM,SAAS,OAAO,QAAQ,GAAG;AAAA;AAAA,SAG7B,YAAW,CAAC,QAEM;AAAA,MACtB,OAAO,WAAW,MAAM,GACrB,OAAO,QAAQ,KAAK,EACpB,IAAI,EAAE,UAAU,MAAM,QAAQ,MAAM,eAAe,CAAC,EACpD,MACC,IACE,GAAG,QAAQ,MAAM,IAAI,OAAO,EAAE,GAC9B,OAAO,UAAU,GAAG,QAAQ,MAAM,SAAS,OAAO,OAAO,IAAI,SAC/D,CACF,EACC,UAAU;AAAA,MACb,IAAI,CAAC,SAAS;AAAA,QACZ,MAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AAAA,MACA,OAAO;AAAA;AAAA,SAGH,YAAW,CAAC,QAA6B;AAAA,MAC7C,OAAO,WAAW,MAAM,GACrB,OAAO,QAAQ,KAAK,EACpB,IAAI,EAAE,UAAU,MAAM,QAAQ,MAAM,eAAe,CAAC,EACpD,MAAM,GAAG,QAAQ,MAAM,IAAI,OAAO,EAAE,CAAC,EACrC,UAAU;AAAA,MACb,IAAI,CAAC,SAAS;AAAA,QACZ,MAAM,IAAI,MAAM,gBAAgB;AAAA,MAClC;AAAA,MACA,IAAI,QAAQ,WAAW,GAAG;AAAA,QACxB,MAAM,KAAK,WAAW,EAAE,IAAI,OAAO,GAAG,CAAC;AAAA,MACzC;AAAA;AAAA,EAEJ;AAAA;;;AC9HK,SAAS,kBAAiD,CAC/D,SACA;AAAA,EACA,MAAM,UAAU,cAAc;AAAA,EAC9B,MAAM,WAAW,eAAe;AAAA,IAC9B,IAAI,QAAQ;AAAA,IACZ;AAAA,IACA,UAAU,QAAQ;AAAA,IAClB,eAAe,QAAQ;AAAA,IACvB,kBAAkB,QAAQ;AAAA,EAC5B,CAAC;AAAA,EACD,MAAM,SAAS,aAAa;AAAA,IAC1B;AAAA,IACA,UAAU,QAAQ;AAAA,EACpB,CAAC;AAAA,EACD,OAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;",
  "debugId": "6563BBC77836F87F64756E2164756E21",
  "names": []
}

package/dist/client/index.d.ts

@@ -0,0 +1,28 @@
+import { ReactNode } from "react";
+import { Treaty } from "@elysiajs/eden";
+import { BunSQLDatabase as BunSQLDatabase2 } from "drizzle-orm/bun-sql";
+type Visibility = "private" | "public";
+interface PurposePolicy {
+	maxSize?: number;
+	allowedMimeTypes?: string[];
+	visibility?: Visibility;
+}
+import { S3Client as S3Client2 } from "bun";
+interface FilesBackendOptions<TPurposes extends string> {
+	db: BunSQLDatabase2;
+	client: S3Client2;
+	policies: Record<TPurposes, PurposePolicy>;
+	publicBaseUrl: string;
+	presignExpiresIn?: number;
+}
+declare function createFilesBackend<const TPurpose extends string>(options: FilesBackendOptions<TPurpose>): {};
+declare function createFilesClient<TBackend extends ReturnType<typeof createFilesBackend<any>>>(domain: string, config?: Treaty.Config);
+type FilesClient = ReturnType<typeof createFilesClient>;
+declare function FilesClientProvider(props: {
+	filesClient: FilesClient;
+	children: ReactNode;
+});
+declare function useFilesClient();
+import { InferMutationOptions } from "eden2query";
+declare function useUpload(options: InferMutationOptions<FilesClient["api"]["files"]["upload"]["post"]>);
+export { useUpload, useFilesClient, createFilesClient, FilesClientProvider, FilesClient };

package/dist/client/index.js

@@ -0,0 +1,41 @@
+// src/client/provider.tsx
+import { createContext, useContext } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var FilesClientContext = createContext(null);
+function FilesClientProvider(props) {
+  return /* @__PURE__ */ jsxDEV(FilesClientContext.Provider, {
+    value: props.filesClient,
+    children: props.children
+  }, undefined, false, undefined, this);
+}
+function useFilesClient() {
+  const context = useContext(FilesClientContext);
+  if (!context) {
+    throw new Error("useFilesClient must be used within a FilesClientProvider");
+  }
+  return context;
+}
+// src/client/client.ts
+import { treaty } from "@elysiajs/eden";
+function createFilesClient(domain, config) {
+  return treaty(domain, config);
+}
+// src/client/hooks.ts
+import { useMutation } from "@tanstack/react-query";
+import { edenMutationOptions } from "eden2query";
+function useUpload(options) {
+  const filesClient = useFilesClient();
+  return useMutation({
+    ...options,
+    ...edenMutationOptions(filesClient.api.files.upload.post)
+  });
+}
+export {
+  useUpload,
+  useFilesClient,
+  createFilesClient,
+  FilesClientProvider
+};
+
+//# debugId=A2BBBD5C97CF307B64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@edkstack/files",
+  "description": "File management utilities for EDK Stack",
+  "version": "0.1.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    "./backend": {
+      "import": {
+        "types": "./dist/backend/index.d.ts",
+        "default": "./dist/backend/index.js"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/client/index.d.ts",
+        "default": "./dist/client/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bunup",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "files",
+    "file-management",
+    "edkstack",
+    "elysia",
+    "drizzle"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "bugs": {
+    "url": ""
+  },
+  "homepage": "",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.13",
+    "bunup": "^0.16.25"
+  },
+  "peerDependencies": {
+    "@elysiajs/eden": "^1.4.6",
+    "@tanstack/react-query": "^5.90.20",
+    "drizzle-orm": "^0.45.1",
+    "elysia": "^1.4.22",
+    "react": "^19.2.4",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "eden2query": "^0.2.0",
+    "nanoid": "^5.1.6"
+  }
+}