@tulip-systems/core 0.8.3 → 0.10.0

package/dist/src/modules/storage/lib/procedures.server.mjs

@@ -0,0 +1,21 @@
+import { confirmUploadInputSchema, presignUploadInputSchema, presignUploadOutputSchema, selectStorageAssetSchema } from "./validators.mjs";
+import { initRPC } from "../../router/handler/init.server.mjs";
+import { z as z$1 } from "zod";
+
+//#region src/modules/storage/lib/procedures.server.ts
+function createStorageProcedures() {
+	const { protectedProcedure } = initRPC();
+	return {
+		presign: protectedProcedure.input(presignUploadInputSchema).output(presignUploadOutputSchema).handler(async ({ context, input }) => context.storage.presignUpload(input)),
+		confirm: protectedProcedure.input(confirmUploadInputSchema).output(selectStorageAssetSchema).handler(async ({ context, input }) => context.storage.confirmUpload(input)),
+		deleteAsset: protectedProcedure.input(z$1.uuid()).output(selectStorageAssetSchema.nullable()).handler(async ({ context, input }) => context.storage.deleteAsset(input)),
+		deleteAssets: protectedProcedure.input(z$1.string().array()).output(z$1.array(selectStorageAssetSchema)).handler(async ({ context, input }) => context.storage.deleteAssets(input)),
+		restoreAsset: protectedProcedure.input(z$1.uuid()).output(selectStorageAssetSchema.nullable()).handler(async ({ context, input }) => context.storage.restoreAsset(input)),
+		restoreAssets: protectedProcedure.input(z$1.string().array()).output(z$1.array(selectStorageAssetSchema)).handler(async ({ context, input }) => context.storage.restoreAssets(input)),
+		purgeAsset: protectedProcedure.input(z$1.uuid()).output(selectStorageAssetSchema.nullable()).handler(async ({ context, input }) => context.storage.purgeAsset(input)),
+		purgeAssets: protectedProcedure.input(z$1.string().array()).output(z$1.array(selectStorageAssetSchema)).handler(async ({ context, input }) => context.storage.purgeAssets(input))
+	};
+}
+
+//#endregion
+export { createStorageProcedures };

package/dist/src/modules/storage/lib/router-handlers.server.d.mts

@@ -0,0 +1,40 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { TulipContext } from "../../config/lib/context.mjs";
+import { NextRequest } from "next/server";
+
+//#region src/modules/storage/lib/router-handlers.server.d.ts
+type RouteCtx = {
+  params: Promise<{
+    rest?: string[];
+  }>;
+};
+type CreateStorageRouteHandlerProps<TSchema extends TDatabaseSchema> = {
+  context: Pick<TulipContext<TSchema>, "auth" | "storage">;
+};
+/**
+ * Creates a catch-all storage route handler for `/api/storage/[[...rest]]`.
+ *
+ * Current support:
+ * - `GET /api/storage/files/:id`:
+ *   resolves a storage asset, enforces visibility checks, and redirects
+ *   to a short-lived signed read URL.
+ *
+ * Reserved for future extension:
+ * - `POST /api/storage/assets/presign`
+ * - `POST /api/storage/assets/confirm`
+ * - additional storage endpoints under the same catch-all route.
+ *
+ * @param props - Route handler dependencies (application context)
+ * @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE
+ */
+declare function createStorageRouteHandler<TSchema extends TDatabaseSchema>({
+  context
+}: CreateStorageRouteHandlerProps<TSchema>): {
+  GET: (request: NextRequest, ctx: RouteCtx) => Promise<Response>;
+  POST: () => Promise<Response>;
+  PUT: () => Promise<Response>;
+  PATCH: () => Promise<Response>;
+  DELETE: () => Promise<Response>;
+};
+//#endregion
+export { createStorageRouteHandler };

package/dist/src/modules/storage/lib/router-handlers.server.mjs

@@ -0,0 +1,123 @@
+import { ServerError } from "../../router/lib/error.server.mjs";
+import { getAssetURLSchema } from "./validators.mjs";
+import { getSession } from "../../auth/lib/helpers.server.mjs";
+import z from "zod";
+import { connection } from "next/server";
+
+//#region src/modules/storage/lib/router-handlers.server.ts
+/**
+* Creates a catch-all storage route handler for `/api/storage/[[...rest]]`.
+*
+* Current support:
+* - `GET /api/storage/files/:id`:
+*   resolves a storage asset, enforces visibility checks, and redirects
+*   to a short-lived signed read URL.
+*
+* Reserved for future extension:
+* - `POST /api/storage/assets/presign`
+* - `POST /api/storage/assets/confirm`
+* - additional storage endpoints under the same catch-all route.
+*
+* @param props - Route handler dependencies (application context)
+* @returns Next.js route handlers for GET, POST, PUT, PATCH, and DELETE
+*/
+function createStorageRouteHandler({ context }) {
+	/**
+	* GET /api/storage/[[...rest]]
+	*
+	* Current route support:
+	* - /api/storage/files/:id
+	*
+	* The file route resolves an asset by id, enforces visibility rules,
+	* and redirects to a short-lived signed object URL.
+	*/
+	async function GET(request, ctx) {
+		const { rest = [] } = await ctx.params;
+		/**
+		* Proxy file request
+		* GET /api/storage/files/:id
+		*/
+		if (rest[0] === "files") {
+			const id = rest[1];
+			if (!id) return Response.json({ error: {
+				code: "BAD_REQUEST",
+				message: "Missing id"
+			} }, { status: 400 });
+			console.info("Proxying file: ", id);
+			try {
+				const asset = await context.storage.getAssetById(id);
+				if (!asset) return Response.json({ error: {
+					code: "NOT_FOUND",
+					message: "Asset not found"
+				} }, { status: 404 });
+				if (asset.visibility === "private") {
+					if (!await getSession(context)) return Response.json({ error: {
+						code: "UNAUTHORIZED",
+						message: "Unauthorized"
+					} }, { status: 401 });
+				}
+				const disposition = request.nextUrl.searchParams.get("disposition") ?? void 0;
+				const options = getAssetURLSchema.parse({ disposition });
+				const url = await context.storage.getObjectURL(asset.id, options);
+				return Response.redirect(url, 307);
+			} catch (error) {
+				if (error instanceof z.ZodError) return Response.json({ error: {
+					code: "BAD_REQUEST",
+					message: "Invalid request input"
+				} }, { status: 400 });
+				if (error instanceof ServerError) {
+					const code = error.code;
+					if (code === "BAD_REQUEST") return Response.json({ error: {
+						code: "BAD_REQUEST",
+						message: error.message
+					} }, { status: 400 });
+					if (code === "NOT_FOUND") return Response.json({ error: {
+						code: "NOT_FOUND",
+						message: error.message
+					} }, { status: 404 });
+					if (code === "UNAUTHORIZED") return Response.json({ error: {
+						code: "UNAUTHORIZED",
+						message: error.message
+					} }, { status: 401 });
+				}
+				if (error instanceof Error && error.message === "Storage asset not found") return Response.json({ error: {
+					code: "NOT_FOUND",
+					message: "Asset not found"
+				} }, { status: 404 });
+				console.error("Storage route error", error);
+				return Response.json({ error: {
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Something went wrong"
+				} }, { status: 500 });
+			}
+		}
+		return Response.json({ error: {
+			code: "NOT_FOUND",
+			message: "Route not found"
+		} }, { status: 404 });
+	}
+	/**
+	* POST, PUT, PATCH, DELETE /api/storage/[[...rest]]
+	*
+	* Reserved for future extension, for example:
+	* - POST /api/storage/assets/presign
+	* - POST /api/storage/assets/confirm
+	*/
+	async function POST() {
+		await connection();
+		return Response.json({ error: {
+			code: "NOT_FOUND",
+			message: "Route not found"
+		} }, { status: 404 });
+	}
+	return {
+		GET,
+		POST,
+		PUT: POST,
+		PATCH: POST,
+		DELETE: POST
+	};
+}
+
+//#endregion
+export { createStorageRouteHandler };

package/dist/src/modules/storage/lib/schema.d.mts

@@ -0,0 +1,291 @@
+import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+
+//#region src/modules/storage/lib/schema.d.ts
+declare const storageAssetStatusEnum: drizzle_orm_pg_core0.PgEnum<["pending", "ready", "error"]>;
+declare const storageAssetVisibilityEnum: drizzle_orm_pg_core0.PgEnum<["private", "public"]>;
+/**
+ * Storage objects table
+ */
+declare const storageAssets: drizzle_orm_pg_core0.PgTableWithColumns<{
+  name: "storage_assets";
+  schema: undefined;
+  columns: {
+    provider: drizzle_orm_pg_core0.PgColumn<{
+      name: "provider";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgText";
+      data: "s3";
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["s3"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    bucket: drizzle_orm_pg_core0.PgColumn<{
+      name: "bucket";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    key: drizzle_orm_pg_core0.PgColumn<{
+      name: "key";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    status: drizzle_orm_pg_core0.PgColumn<{
+      name: "status";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgEnumColumn";
+      data: "error" | "pending" | "ready";
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["pending", "ready", "error"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    visibility: drizzle_orm_pg_core0.PgColumn<{
+      name: "visibility";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgEnumColumn";
+      data: "private" | "public";
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["private", "public"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    size: drizzle_orm_pg_core0.PgColumn<{
+      name: "size";
+      tableName: "storage_assets";
+      dataType: "number";
+      columnType: "PgInteger";
+      data: number;
+      driverParam: string | number;
+      notNull: false;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    contentType: drizzle_orm_pg_core0.PgColumn<{
+      name: "contentType";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgVarchar";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: 255;
+    }>;
+    uploadId: drizzle_orm_pg_core0.PgColumn<{
+      name: "uploadId";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    name: drizzle_orm_pg_core0.PgColumn<{
+      name: "name";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    metadata: drizzle_orm_pg_core0.PgColumn<{
+      name: "metadata";
+      tableName: "storage_assets";
+      dataType: "json";
+      columnType: "PgJsonb";
+      data: unknown;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    etag: drizzle_orm_pg_core0.PgColumn<{
+      name: "etag";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgText";
+      data: string;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    uploadedAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "uploadedAt";
+      tableName: "storage_assets";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    deletedAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "deletedAt";
+      tableName: "storage_assets";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    id: drizzle_orm_pg_core0.PgColumn<{
+      name: "id";
+      tableName: "storage_assets";
+      dataType: "string";
+      columnType: "PgUUID";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: true;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    createdAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "createdAt";
+      tableName: "storage_assets";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    updatedAt: drizzle_orm_pg_core0.PgColumn<{
+      name: "updatedAt";
+      tableName: "storage_assets";
+      dataType: "date";
+      columnType: "PgTimestamp";
+      data: Date;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+//#endregion
+export { storageAssetStatusEnum, storageAssetVisibilityEnum, storageAssets };

package/dist/src/modules/storage/lib/schema.mjs

@@ -0,0 +1,37 @@
+import { baseColumns } from "../../database/lib/helpers.mjs";
+import { storageProviders } from "../providers/lib/constants.mjs";
+import { index, pgEnum, pgTable, unique } from "drizzle-orm/pg-core";
+
+//#region src/modules/storage/lib/schema.ts
+const storageAssetStatusEnum = pgEnum("storage_asset_status", [
+	"pending",
+	"ready",
+	"error"
+]);
+const storageAssetVisibilityEnum = pgEnum("storage_asset_visibility", ["private", "public"]);
+/**
+* Storage objects table
+*/
+const storageAssets = pgTable("storage_assets", (t) => ({
+	...baseColumns,
+	provider: t.text({ enum: storageProviders }).notNull(),
+	bucket: t.text().notNull(),
+	key: t.text().notNull(),
+	status: storageAssetStatusEnum().notNull(),
+	visibility: storageAssetVisibilityEnum().notNull().default("private"),
+	size: t.integer().default(0),
+	contentType: t.varchar({ length: 255 }),
+	uploadId: t.uuid().notNull().defaultRandom(),
+	name: t.text(),
+	metadata: t.jsonb(),
+	etag: t.text(),
+	uploadedAt: t.timestamp().defaultNow().notNull(),
+	deletedAt: t.timestamp()
+}), (t) => [
+	unique("storage_assets_provider_bucket_key_unique").on(t.provider, t.bucket, t.key),
+	index("storage_assets_status_idx").on(t.status),
+	index("storage_assets_bucket_key_idx").on(t.bucket, t.key)
+]);
+
+//#endregion
+export { storageAssetStatusEnum, storageAssetVisibilityEnum, storageAssets };