External/portabase
1
0
Fork 0
mirror of https://github.com/Portabase/portabase.git synced 2026-07-14 11:16:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat: Working version with google drive storage.

Browse Source
This commit is contained in:
charlesgauthereau
2026-01-24 12:13:55 +01:00
parent 4eeeef3427
commit a64a80910d
18 changed files with 397 additions and 562 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/api/agent/[agentId]/status/helpers.ts
+4 -27
View File
@@ -1,16 +1,12 @@
import {NextResponse} from "next/server";
import {Body} from "./route";
import {isUuidv4} from "@/utils/verify-uuid";
import {getFileUrlPresignedLocal, getFileUrlPreSignedS3Action} from "@/features/upload/private/upload.action";
import {Agent} from "@/db/schema/08_agent";
import {Database} from "@/db/schema/07_database";
import * as drizzleDb from "@/db";
import {db as dbClient} from "@/db";
import {and, eq, inArray} from "drizzle-orm";
import {dbmsEnumSchema, EDbmsSchema} from "@/db/schema/types";
import {ServerActionResult} from "@/types/action-type";
import {SafeActionResult} from "next-safe-action";
import {ZodString} from "zod";
import {withUpdatedAt} from "@/db/utils";
import type {StorageInput} from "@/features/storages/types";
import {dispatchStorage} from "@/features/storages/dispatch";
@@ -83,10 +79,6 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
.returning();
// const backup = await dbClient.query.backup.findFirst({
// where: and(eq(drizzleDb.schemas.backup.databaseId, databaseUpdated.id), eq(drizzleDb.schemas.backup.status, "waiting"))
// })
const activeBackup = await dbClient.query.backup.findFirst({
where: and(
eq(drizzleDb.schemas.backup.databaseId, databaseUpdated.id),
@@ -116,25 +108,6 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
restoreAction = true
// const backupToRestore = await dbClient.query.backup.findFirst({
// where: eq(drizzleDb.schemas.backup.id, restoration.backupId),
// with: {
// database: {
// with: {
// project: true
// }
// }
// }
// })
// const [settings] = await dbClient.select().from(drizzleDb.schemas.setting).where(eq(drizzleDb.schemas.setting.name, "system")).limit(1);
// if (!settings) {
// return NextResponse.json(
// {error: "Unable to find settings"},
// {status: 500}
// );
// }
if (!restoration.backupStorage || restoration.backupStorage.status != "success" || !restoration.backupStorage.path) {
restoreAction = false
continue;
@@ -147,6 +120,10 @@ export async function handleDatabases(body: Body, agent: Agent, lastContact: Dat
path: restoration.backupStorage.path,
signedUrl: true,
},
metadata: {
storageId: restoration.backupStorage.storageChannelId,
fileKind: "backups"
}
};
app/api/files/route.ts → app/api/files/backups/route.ts
+9 -15
View File
@@ -1,8 +1,5 @@
import {NextResponse} from "next/server";
import path from "path";
import {db} from "@/db";
import {eq} from "drizzle-orm";
import * as drizzleDb from "@/db";
import type {StorageInput} from "@/features/storages/types";
import {dispatchStorage} from "@/features/storages/dispatch";
import {Readable} from "node:stream";
@@ -15,17 +12,10 @@ export async function GET(
const token = searchParams.get('token');
const expires = searchParams.get('expires');
const pathFromUrl = searchParams.get('path');
const storageId = searchParams.get('storageId');
if (!pathFromUrl) {
return NextResponse.json({error: "Missing file path in search params"}, {status: 404})
}
const localStorageChannel = await db.query.storageChannel.findFirst({
where: eq(drizzleDb.schemas.storageChannel.provider, "local"),
})
if (!localStorageChannel) {
return NextResponse.json({error: "No local storage channel found"})
if (!pathFromUrl || !storageId) {
return NextResponse.json({error: "Missing search params"}, {status: 404})
}
const input: StorageInput = {
@@ -34,14 +24,18 @@ export async function GET(
path: pathFromUrl,
signedUrl: true,
},
metadata: {
storageId: storageId,
fileKind: "backups",
}
};
console.debug(input);
const result = await dispatchStorage(input, undefined, localStorageChannel.id);
const result = await dispatchStorage(input, undefined, storageId);
if (!result.success) {
return NextResponse.json({error: "Enable to get file from local storage channel, an error occurred !"})
return NextResponse.json({error: "Enable to get file from privided storage channel, an error occurred !"})
}
app/api/images/[fileName]/route.ts → app/api/files/images/[fileName]/route.ts
+22 -16
View File
@@ -1,10 +1,6 @@
import {NextResponse} from "next/server";
import {auth} from "@/lib/auth/auth";
import {headers} from "next/headers";
import {checkFileExistsInBucket, getObjectFromClient} from "@/utils/s3-file-management";
import {env} from "@/env.mjs";
import * as stream from "node:stream";
import path from "path";
import {db} from "@/db";
import * as drizzleDb from "@/db";
import {eq} from "drizzle-orm";
@@ -16,28 +12,34 @@ export async function GET(
req: Request,
{params}: { params: Promise<{ fileName: string }> }
) {
const {searchParams} = new URL(req.url);
const fileName = (await params).fileName;
const storageId = searchParams.get('storageId');
if (!fileName) return NextResponse.json({error: "Missing file parameter"}, {status: 400});
const session = await auth.api.getSession({headers: await headers()});
if (!session) return NextResponse.json({error: "Unauthorized"}, {status: 403});
const settings = await db.query.setting.findFirst({
where: eq(drizzleDb.schemas.setting.name, "system"),
with: {
storageChannel: true
}
});
if (!settings || !settings.storageChannel) {
return NextResponse.json({error: "Unable to get settings or no default storage channel"});
if (!storageId) {
return NextResponse.json({error: "Missing storageId in search params"}, {status: 404})
}
// const settings = await db.query.setting.findFirst({
// where: eq(drizzleDb.schemas.setting.name, "system"),
// with: {
// storageChannel: true
// }
// });
//
// if (!settings || !settings.storageChannel) {
// return NextResponse.json({error: "Unable to get settings or no default storage channel"});
// }
const ext = fileName.split(".").pop()?.toLowerCase();
const contentType =
ext === "png"
@@ -58,10 +60,14 @@ export async function GET(
action: "get",
data: {
path: path,
},
metadata: {
storageId: storageId,
fileKind: "images"
}
}
const result = await dispatchStorage(input, undefined, settings.storageChannel.id);
const result = await dispatchStorage(input, undefined, storageId);
if (!result.file || !Buffer.isBuffer(result.file)) {
console.error(`An error occurred while getting file :`, result);
app/api/google/drive/callback/route.ts
+19 -27
View File
@@ -1,31 +1,23 @@
import { NextResponse } from "next/server";
import { google } from "googleapis";
export async function GET(request: Request) {
try {
const url = new URL(request.url);
const code = url.searchParams.get("code");
const clientId = url.searchParams.get("clientId");
const clientSecret = url.searchParams.get("clientSecret");
const redirectUri = url.searchParams.get("redirectUri");
const url = new URL(request.url);
const code = url.searchParams.get("code");
if (!code || !clientId || !clientSecret || !redirectUri) {
return NextResponse.json({ error: "Missing parameters" }, { status: 400 });
const success = Boolean(code);
return new Response(
`
<!DOCTYPE html>
<html>
<body>
<h1>${success ? "Success" : "Failed"}</h1>
</body>
</html>
`,
{
status: success ? 200 : 400,
headers: {
"Content-Type": "text/html; charset=utf-8",
},
}
try {
const oauth2Client = new google.auth.OAuth2(clientId, clientSecret, redirectUri);
const { tokens } = await oauth2Client.getToken(code);
// Save tokens.refresh_token securely in your DB here
return NextResponse.json(tokens);
} catch (err: any) {
console.error("Error exchanging code:", err);
return NextResponse.json({ error: "Failed to exchange code" }, { status: 500 });
}
} catch (error) {
console.error("Error in GET handler:", error);
return NextResponse.json({ error: "Internal server error" }, { status: 500 });
}
);
}
proxy.ts
+2 -2
View File
@@ -54,8 +54,8 @@ function checkRouteExists(pathname: string) {
/^\/api\/agent\/[^/]+\/status\/?$/,
/^\/api\/agent\/[^/]+\/backup\/?$/,
/^\/api\/agent\/[^/]+\/restore\/?$/,
/^\/api\/files\/?$/,
/^\/api\/images\/[^/]+\/?$/,
/^\/api\/files\/images\/[^/]+\/?$/,
/^\/api\/files\/backups\/?$/,
/^\/api\/events\/?$/,
/^\/api\/init\/?$/,
/^\/api\/config\/?$/,
src/components/wrappers/dashboard/admin/channels/channel/channel-form/channel-form.tsx
+2 -1
View File
@@ -250,4 +250,5 @@ export const ChannelForm = ({onSuccessAction, organization, defaultValues, kind}
</div>
</Form>
);
};
};
src/components/wrappers/dashboard/admin/channels/channel/channel-form/providers/storages/forms/google-drive.form.tsx
+61 -280
View File
@@ -1,195 +1,3 @@
// import {UseFormReturn} from "react-hook-form";
// import {FormControl, FormField, FormItem, FormLabel, FormMessage} from "@/components/ui/form";
// import {Input} from "@/components/ui/input";
// import {Separator} from "@/components/ui/separator";
//
//
// type StorageGoogleDriveFormProps = {
// form: UseFormReturn<any, any, any>
// }
//
//
// export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
// return (
// <>
// <Separator className="my-1"/>
// <FormField
// control={form.control}
// name="config.clientEmail"
// render={({field}) => (
// <FormItem>
// <FormLabel>Client Email</FormLabel>
// <FormControl>
// <Input {...field} placeholder="xxx@xxx.iam.gserviceaccount.com"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
// <FormField
// control={form.control}
// name="config.privateKey"
// render={({field}) => (
// <FormItem>
// <FormLabel>Private Key</FormLabel>
// <FormControl>
// <Input {...field} placeholder="xxxxxxxxxxxx"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
// <FormField
// control={form.control}
// name="config.folderId"
// render={({field}) => (
// <FormItem>
// <FormLabel>Folder Id</FormLabel>
// <FormControl>
// <Input {...field} placeholder="xxxxxxxxxxxx"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// </>
// )
// }
// "use client";
//
// import {UseFormReturn} from "react-hook-form";
// import {FormControl, FormField, FormItem, FormLabel, FormMessage} from "@/components/ui/form";
// import {Input} from "@/components/ui/input";
// import {Separator} from "@/components/ui/separator";
// import {Button} from "@/components/ui/button";
// import {getServerUrl} from "@/utils/get-server-url";
//
// type StorageGoogleDriveFormProps = {
// form: UseFormReturn<any, any, any>
// };
//
// export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
// const handleConnect = async () => {
// const clientId = form.getValues("config.clientId");
// // const baseUrl = getServerUrl();
// // const redirectUri = form.getValues("config.redirectUri") || "http://localhost:3000/oauth2callback";
// const redirectUri = "http://localhost:8887/dashboard/storages/channels";
//
// if (!clientId) {
// alert("Please fill in Client ID first");
// return;
// }
//
// // Construct Google OAuth URL
// const scope = encodeURIComponent("https://www.googleapis.com/auth/drive.file");
// const url = `https://accounts.google.com/o/oauth2/v2/auth?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&response_type=code&scope=${scope}&access_type=offline&prompt=consent`;
//
// // Open consent screen in a new tab
// window.open(url, "_blank");
// };
//
// return (
// <>
// <Separator className="my-1"/>
//
// {/* Client ID */}
// <FormField
// control={form.control}
// name="config.clientId"
// render={({field}) => (
// <FormItem>
// <FormLabel>Client ID</FormLabel>
// <FormControl>
// <Input {...field} placeholder="XXXX.apps.googleusercontent.com"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// {/* Client Secret */}
// <FormField
// control={form.control}
// name="config.clientSecret"
// render={({field}) => (
// <FormItem>
// <FormLabel>Client Secret</FormLabel>
// <FormControl>
// <Input {...field} placeholder="XXXXXXXXXXXX"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// {/* Redirect URI */}
// <FormField
// control={form.control}
// name="config.redirectUri"
// render={({field}) => (
// <FormItem>
// <FormLabel>Redirect URI</FormLabel>
// <FormControl>
// <Input {...field} placeholder="http://localhost:3000/oauth2callback"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// {/* Refresh Token */}
// <FormField
// control={form.control}
// name="config.refreshToken"
// render={({field}) => (
// <FormItem>
// <FormLabel>Refresh Token</FormLabel>
// <FormControl>
// <Input {...field} placeholder="Paste refresh token here"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// {/* Folder ID */}
// <FormField
// control={form.control}
// name="config.folderId"
// render={({field}) => (
// <FormItem>
// <FormLabel>Folder ID</FormLabel>
// <FormControl>
// <Input {...field} placeholder="XXXXXXXXXXXXXXXXXXXX"/>
// </FormControl>
// <FormMessage/>
// </FormItem>
// )}
// />
//
// <FormField
// control={form.control}
// name="oauth.connect"
// render={() => (
// <FormItem>
// <FormLabel>OAuth2 Connect</FormLabel>
// <FormControl>
// <Button type="button" onClick={handleConnect}>
// Connect Google Drive
// </Button>
// </FormControl>
// <FormMessage>
// Clicking this will open Google’s consent screen. After granting access, copy the authorization code and exchange it for a refresh token in your backend.
// </FormMessage>
// </FormItem>
// )}
// />
// </>
// );
// };
//
"use client";
import {UseFormReturn} from "react-hook-form";
@@ -197,33 +5,42 @@ import {FormControl, FormField, FormItem, FormLabel, FormMessage} from "@/compon
import {Input} from "@/components/ui/input";
import {Separator} from "@/components/ui/separator";
import {Button} from "@/components/ui/button";
import {PasswordInput} from "@/components/ui/password-input";
import {
googleDriveRefreshTokenAction
} from "@/components/wrappers/dashboard/admin/channels/channel/channel-form/providers/storages/forms/google-drive/helpers";
import {toast} from "sonner";
type StorageGoogleDriveFormProps = {
form: UseFormReturn<any, any, any>;
form: UseFormReturn<any>;
};
export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
const refreshToken = form.watch("config.refreshToken");
const isConnected = Boolean(refreshToken);
const handleConnect = () => {
const clientId = form.getValues("config.clientId");
const redirectUri = form.getValues("config.redirectUri") || `${window.location.origin}/api/google/drive/callback`;
const clientSecret = form.getValues("config.clientSecret");
const redirectUri = `${window.location.origin}/api/google/drive/callback`;
if (!clientId) {
alert("Please fill in Client ID first");
if (!clientId || !clientSecret) {
form.setError("config.clientId", {message: "Client ID and Secret are required"});
return;
}
const scope = encodeURIComponent("https://www.googleapis.com/auth/drive.file");
const oauthUrl = `https://accounts.google.com/o/oauth2/v2/auth?client_id=${clientId}&redirect_uri=${encodeURIComponent(
redirectUri
)}&response_type=code&scope=${scope}&access_type=offline&prompt=consent`;
const oauthUrl =
`https://accounts.google.com/o/oauth2/v2/auth` +
`?client_id=${clientId}` +
`&redirect_uri=${encodeURIComponent(redirectUri)}` +
`&response_type=code` +
`&scope=${scope}` +
`&access_type=offline` +
`&prompt=consent`;
// Open OAuth in a new tab
const oauthWindow = window.open(oauthUrl, "_blank", "width=500,height=600");
// Poll the window for the refresh token (after the redirect)
const interval = setInterval(async () => {
try {
if (!oauthWindow || oauthWindow.closed) {
@@ -231,48 +48,49 @@ export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
return;
}
// Check if redirected to your server callback
if (oauthWindow.location.href.startsWith(`${window.location.origin}/api/google/drive/callback`)) {
const params = new URL(oauthWindow.location.href).searchParams;
const code = params.get("code");
console.log(code)
if (code) {
if (oauthWindow.location.href.startsWith(redirectUri)) {
const code = new URL(oauthWindow.location.href).searchParams.get("code");
if (!code) return;
const clientId = form.getValues("config.clientId");
const clientSecret = form.getValues("config.clientSecret");
const redirectUri =
form.getValues("config.redirectUri") ||
`${window.location.origin}/api/google/drive/callback`;
const result = await googleDriveRefreshTokenAction({
code,
clientId,
clientSecret,
redirectUri,
});
const inner = result?.data;
// Exchange code for refresh token
const data = await googleDriveRefreshTokenAction({
code: code,
clientId: clientId,
clientSecret: clientSecret,
redirectUri: redirectUri,
})
if (inner?.success) {
toast.success(inner.actionSuccess?.message);
if (data.data.refreshToken) {
console.log(data.data.refreshToken)
form.setValue("config.refreshToken", data.data.refreshToken); // auto-update the field
if (!inner.value) {
form.setError("config", {message: "OAuth succeeded but no refresh token returned"});
return;
}
oauthWindow.close();
clearInterval(interval);
form.setValue("config.refreshToken", inner.value, {
shouldValidate: true,
shouldDirty: true,
});
} else {
toast.error(inner?.actionError?.message);
}
oauthWindow.close();
clearInterval(interval);
}
} catch (err) {
// ignore cross-origin errors until redirect happens
} catch {
// Ignore cross-origin errors until redirect
}
}, 500);
};
return (
<>
<Separator className="my-1"/>
{/* Client ID */}
<FormField
control={form.control}
name="config.clientId"
@@ -280,14 +98,13 @@ export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
<FormItem>
<FormLabel>Client ID</FormLabel>
<FormControl>
<Input {...field} placeholder="XXXX.apps.googleusercontent.com"/>
<Input {...field} placeholder="xxxx.apps.googleusercontent.com"/>
</FormControl>
<FormMessage/>
</FormItem>
)}
/>
{/* Client Secret */}
<FormField
control={form.control}
name="config.clientSecret"
@@ -295,45 +112,13 @@ export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
<FormItem>
<FormLabel>Client Secret</FormLabel>
<FormControl>
<Input {...field} placeholder="XXXXXXXXXXXX"/>
<PasswordInput {...field} />
</FormControl>
<FormMessage/>
</FormItem>
)}
/>
{/* Redirect URI */}
<FormField
control={form.control}
name="config.redirectUri"
render={({field}) => (
<FormItem>
<FormLabel>Redirect URI</FormLabel>
<FormControl>
<Input {...field} placeholder="http://localhost:3000/api/google-drive/callback"/>
</FormControl>
<FormMessage/>
</FormItem>
)}
/>
{/* Refresh Token */}
{/*<FormField*/}
{/* control={form.control}*/}
{/* name="config.refreshToken"*/}
{/* render={({field}) => (*/}
{/* <FormItem>*/}
{/* <FormLabel>Refresh Token</FormLabel>*/}
{/* <FormControl>*/}
{/* <Input {...field} placeholder="Will be filled after OAuth flow"/>*/}
{/* </FormControl>*/}
{/* <FormMessage/>*/}
{/* </FormItem>*/}
{/* )}*/}
{/*/>*/}
{/* Folder ID */}
<FormField
control={form.control}
name="config.folderId"
@@ -341,30 +126,26 @@ export const StorageGoogleDriveForm = ({form}: StorageGoogleDriveFormProps) => {
<FormItem>
<FormLabel>Folder ID</FormLabel>
<FormControl>
<Input {...field} placeholder="XXXXXXXXXXXXXXXXXXXX"/>
<Input {...field} />
</FormControl>
<FormMessage/>
</FormItem>
)}
/>
<FormField
control={form.control}
name="config.refreshToken"
render={({ field }) => (
<FormItem>
<FormLabel>Refresh Token</FormLabel>
<FormControl>
<Input {...field} placeholder="Will be filled after OAuth flow" readOnly />
</FormControl>
<FormMessage>
The refresh token will automatically appear here after connecting.
</FormMessage>
</FormItem>
)}
/>
<input type="hidden" {...form.register("config.refreshToken")} />
<Button type="button" onClick={handleConnect}> Connect Google Drive </Button>
<div className="flex items-center gap-3">
<Button type="button" onClick={handleConnect}>
{isConnected ? "Reconnect Google Drive" : "Connect Google Drive"}
</Button>
{isConnected && (
<span className="text-sm text-green-600 font-medium">
Google Drive connected
</span>
)}
</div>
</>
);
};
src/components/wrappers/dashboard/admin/channels/channel/channel-form/providers/storages/forms/google-drive/helpers.ts
+37 -24
View File
@@ -1,8 +1,7 @@
"use server"
import {userAction} from "@/lib/safe-actions/actions";
import {string, z} from "zod";
import {google} from "googleapis";
import {z} from "zod";
import {ServerActionResult} from "@/types/action-type";
export const googleDriveRefreshTokenAction = userAction.schema(
@@ -11,29 +10,43 @@ export const googleDriveRefreshTokenAction = userAction.schema(
clientId: z.string(),
clientSecret: z.string(),
redirectUri: z.string(),
})).action(async ({parsedInput}) => {
// google.auth.OAuth2
// const oauth2Client = new google.auth.OAuth2(parsedInput.clientId,parsedInput.clientSecret, parsedInput.redirectUri);
// const { tokens } = await oauth2Client.getToken(parsedInput.code);
})).action(async ({parsedInput}): Promise<ServerActionResult<string>> => {
const {code, clientId, clientSecret, redirectUri} = parsedInput;
const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
client_id: parsedInput.clientId,
client_secret: parsedInput.clientSecret,
code: parsedInput.code,
grant_type: "authorization_code",
redirect_uri: parsedInput.redirectUri,
}),
});
try {
console.log(tokenRes);
const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
client_id: clientId,
client_secret: clientSecret,
code: code,
grant_type: "authorization_code",
redirect_uri: redirectUri,
}),
});
const tokens = await tokenRes.json();
return {
success: true,
value: tokens.refresh_token,
actionSuccess: {
message: "Refresh token successfully fetched",
messageParams: {code: code},
},
};
}catch {
return {
success: false,
actionError: {
message: "An error occurred",
status: 404,
messageParams: {code: code},
},
};
}
const tokens = await tokenRes.json();
console.log(tokens.refresh_token);
return {
refreshToken: tokens.refresh_token,
};
});
src/components/wrappers/dashboard/database/backup/actions/backup-actions.action.ts
+4
View File
@@ -51,6 +51,10 @@ export const downloadBackupAction = userAction.schema(
path: backupStorage.path,
signedUrl: true,
},
metadata: {
storageId: backupStorage.storageChannelId,
fileKind: "backups"
}
};
console.log(input)
src/features/storages/dispatch.ts
+2 -1
View File
@@ -89,7 +89,8 @@ export async function dispatchStorage(
return await dispatchViaProvider(
channel.provider as StorageProviderKind,
channel.config,
input
input,
);
src/features/storages/helpers.ts
+41 -2
View File
@@ -1,11 +1,19 @@
import {Backup, DatabaseWith} from "@/db/schema/07_database";
import {dispatchStorage} from "@/features/storages/dispatch";
import type {StorageInput, StorageResult} from "@/features/storages/types";
import type {
StorageGetInput,
StorageInput,
StorageMetaData,
StorageResult,
StorageUploadInput
} from "@/features/storages/types";
import * as drizzleDb from "@/db";
import {withUpdatedAt} from "@/db/utils";
import {eq} from "drizzle-orm";
import {db} from "@/db";
import {createHash} from "crypto";
import crypto, {createHash} from "crypto";
import {getServerUrl} from "@/utils/get-server-url";
import path from "path";
function computeChecksum(buffer: Buffer): string {
return createHash("sha256").update(buffer).digest("hex");
@@ -114,3 +122,34 @@ export async function storeBackupFiles(
return results;
}
export async function generateFileUrl(input: { data: StorageGetInput | StorageUploadInput, metadata?: StorageMetaData }): Promise<string | null> {
const fileName = path.basename(input.data.path);
const baseUrl = getServerUrl();
const metadata = input.metadata;
if (!metadata){
return null;
}
let params = new URLSearchParams({
storageId: metadata.storageId,
});
if (metadata.fileKind === "backups") {
const crypto = require("crypto");
const expiresAt = Date.now() + 60 * 1000;
const token = crypto.createHash("sha256").update(`${fileName}${expiresAt}`).digest("hex");
params.set("path", input.data.path);
params.set("token", token);
params.set("expires", expiresAt.toString());
return `${baseUrl}/api/files/${metadata.fileKind}/?${params.toString()}`
}else if (metadata.fileKind === "images") {
return `${baseUrl}/api/files/${metadata.fileKind}/${fileName}?${params.toString()}`
}else {
return null
}
}
src/features/storages/providers/google-drive/helpers.ts
+62
View File
@@ -70,4 +70,66 @@ export async function findFileByName(
});
return res.data.files?.[0]?.id ?? null;
}
export async function ensureFolderPath(client: any, path: string, rootFolderId: string): Promise<string> {
const parts = path.split("/").filter(Boolean); // ["backups", "project-1"]
let parentId = rootFolderId;
for (const part of parts) {
const res = await client.files.list({
q: `'${parentId}' in parents and name='${part}' and mimeType='application/vnd.google-apps.folder' and trashed=false`,
fields: "files(id, name)",
supportsAllDrives: true,
includeItemsFromAllDrives: true,
});
if (res.data.files && res.data.files.length > 0) {
parentId = res.data.files[0].id!;
} else {
const folder = await client.files.create({
requestBody: {
name: part,
mimeType: "application/vnd.google-apps.folder",
parents: [parentId],
},
fields: "id",
supportsAllDrives: true,
});
parentId = folder.data.id!;
}
}
return parentId;
}
export async function resolveFilePath(client: any, fullPath: string, rootFolderId: string): Promise<string | null> {
const parts = fullPath.split("/").filter(Boolean);
const fileName = parts.pop()!;
let parentId = rootFolderId;
for (const part of parts) {
const res = await client.files.list({
q: `'${parentId}' in parents and name='${part}' and mimeType='application/vnd.google-apps.folder' and trashed=false`,
fields: "files(id, name)",
supportsAllDrives: true,
includeItemsFromAllDrives: true,
});
if (res.data.files && res.data.files.length > 0) {
parentId = res.data.files[0].id!;
} else {
return null;
}
}
const fileRes = await client.files.list({
q: `'${parentId}' in parents and name='${fileName}' and trashed=false`,
fields: "files(id, name)",
supportsAllDrives: true,
includeItemsFromAllDrives: true,
});
return fileRes.data.files?.[0]?.id || null;
}
src/features/storages/providers/google-drive/index.ts
+67 -132
View File
@@ -1,154 +1,71 @@
"use server"
import {StorageDeleteInput, StorageGetInput, StorageResult, StorageUploadInput} from '../../types';
import {StorageDeleteInput, StorageGetInput, StorageMetaData, StorageResult, StorageUploadInput} from '../../types';
import {GoogleDriveConfig} from "@/features/storages/providers/google-drive/types";
import {findFileByName, getGoogleDriveClient} from "@/features/storages/providers/google-drive/helpers";
import {
ensureFolderPath,
findFileByName,
getGoogleDriveClient, resolveFilePath
} from "@/features/storages/providers/google-drive/helpers";
import {Readable} from "node:stream";
import {generateFileUrl} from "@/features/storages/helpers";
// export async function uploadGoogleDrive(
// config: GoogleDriveConfig,
// input: { data: StorageUploadInput }
// ): Promise<StorageResult> {
// const client = await getGoogleDriveClient(config);
//
// const name = input.data.path;
//
// const existing = await findFileByName(client, name, config.folderId);
// if (existing) {
// return {
// success: false,
// provider: "google-drive",
// error: "File already exists"
// };
// }
//
// await client.files.create({
// requestBody: {
// name,
// parents: [config.folderId],
// },
// media: {
// body: input.data.file as Buffer,
// },
// });
//
//
// return {
// success: true,
// provider: 'google-drive',
// };
// }
//
// export async function getGoogleDrive(
// config: GoogleDriveConfig,
// input: { data: StorageGetInput }
// ): Promise<StorageResult> {
// const client = await getGoogleDriveClient(config);
// const name = input.data.path;
//
// const fileId = await findFileByName(client, name, config.folderId);
// if (!fileId) {
// return {success: false, provider: "google-drive", error: "File not found"};
// }
//
// const res = await client.files.get(
// {fileId, alt: "media"},
// {responseType: "arraybuffer"}
// );
//
// return {
// success: true,
// provider: "google-drive",
// file: Buffer.from(res.data as ArrayBuffer),
// };
// }
//
//
// export async function deleteGoogleDrive(
// config: GoogleDriveConfig,
// input: { data: StorageDeleteInput }
// ): Promise<StorageResult> {
// const client = await getGoogleDriveClient(config);
// const name = input.data.path;
//
// const fileId = await findFileByName(client, name, config.folderId);
// if (!fileId) {
// return {success: false, provider: "google-drive", error: "File not found"};
// }
//
// await client.files.delete({fileId});
//
// return {
// success: true,
// provider: "google-drive"
// };
// }
//
//
// export async function pingGoogleDrive(config: GoogleDriveConfig): Promise<StorageResult> {
// try {
// const drive = await getGoogleDriveClient(config);
// const name = `ping-${Date.now()}.txt`;
//
// const buffer = Buffer.from("ping");
//
// const file = await drive.files.create({
// requestBody: {
// name,
// parents: [config.folderId],
// },
// media: {
// mimeType: "text/plain",
// body: Readable.from(buffer),
// },
// fields: "id",
// });
// console.log(file)
//
// await drive.files.get({fileId: file.data.id!});
// await drive.files.delete({fileId: file.data.id!});
//
// return {
// success: true,
// provider: "google-drive",
// response: "Google Drive storage OK",
// };
// } catch (err: any) {
// return {
// success: false,
// provider: "google-drive",
// response: err.message,
// };
// }
// }
export async function uploadGoogleDrive(
config: GoogleDriveConfig,
input: { data: StorageUploadInput }
input: { data: StorageUploadInput, metadata?: StorageMetaData },
): Promise<StorageResult> {
const client = await getGoogleDriveClient(config);
const name = input.data.path;
const existing = await findFileByName(client, name, config.folderId);
const fullPath = input.data.path;
const pathParts = fullPath.split("/").filter(Boolean);
const fileName = pathParts.pop()!;
const folderPath = pathParts.join("/");
const folderId = folderPath
? await ensureFolderPath(client, folderPath, config.folderId)
: config.folderId;
const existing = await findFileByName(client, fileName, folderId);
if (existing) return {success: false, provider: "google-drive", error: "File already exists"};
await client.files.create({
requestBody: {name, parents: [config.folderId]},
requestBody: {name: fileName, parents: [folderId]},
media: {body: Readable.from(input.data.file as Buffer)},
fields: "id",
supportsAllDrives: true,
});
return {success: true, provider: 'google-drive'};
if (input.data.url) {
const url = await generateFileUrl(input);
if (!url) {
return {
success: false,
provider: "google-drive",
response: "Unable to get url file"
};
}
return {
success: true,
provider: 'google-drive',
url: url
};
}
return {
success: true,
provider: 'google-drive',
};
}
export async function getGoogleDrive(
config: GoogleDriveConfig,
input: { data: StorageGetInput }
input: { data: StorageGetInput, metadata: StorageMetaData },
): Promise<StorageResult> {
const client = await getGoogleDriveClient(config);
const name = input.data.path;
const fileId = await findFileByName(client, name, config.folderId);
const fileId = await resolveFilePath(client, input.data.path, config.folderId);
if (!fileId) return {success: false, provider: "google-drive", error: "File not found"};
const res = await client.files.get(
@@ -156,6 +73,26 @@ export async function getGoogleDrive(
{responseType: "arraybuffer"}
);
if (input.data.signedUrl) {
const url = await generateFileUrl(input);
if (!url) {
return {
success: false,
provider: "google-drive",
response: "Unable to get url"
};
}
return {
success: true,
provider: "google-drive",
file: Buffer.from(res.data as ArrayBuffer),
url: url,
};
}
return {
success: true,
provider: "google-drive",
@@ -165,12 +102,10 @@ export async function getGoogleDrive(
export async function deleteGoogleDrive(
config: GoogleDriveConfig,
input: { data: StorageDeleteInput }
input: { data: StorageDeleteInput, metadata?: StorageMetaData },
): Promise<StorageResult> {
const client = await getGoogleDriveClient(config);
const name = input.data.path;
const fileId = await findFileByName(client, name, config.folderId);
const fileId = await resolveFilePath(client, input.data.path, config.folderId);
if (!fileId) return {success: false, provider: "google-drive", error: "File not found"};
await client.files.delete({fileId, supportsAllDrives: true});
@@ -192,7 +127,7 @@ export async function pingGoogleDrive(config: GoogleDriveConfig): Promise<Storag
});
await drive.files.get({fileId: file.data.id!, supportsAllDrives: true});
// await drive.files.delete({fileId: file.data.id!, supportsAllDrives: true});
await drive.files.delete({fileId: file.data.id!, supportsAllDrives: true});
return {success: true, provider: "google-drive", response: "Google Drive storage OK"};
} catch (err: any) {
src/features/storages/providers/google-drive/types.ts
+2 -4
View File
@@ -1,4 +1,3 @@
// export type GoogleDriveConfig = {
// clientEmail: string;
// privateKey: string;
@@ -9,7 +8,6 @@
export type GoogleDriveConfig = {
clientId: string;
clientSecret: string;
refreshToken: string; // from OAuth flow
// redirectUri: string; // e.g., http://localhost:3000/oauth2callback
folderId: string; // target folder in your Drive
refreshToken: string;
folderId: string;
};
src/features/storages/providers/index.ts
+3 -3
View File
@@ -1,7 +1,7 @@
import type {
import {
StorageProviderKind,
StorageInput,
StorageResult,
StorageResult, StorageMetaData,
} from '../types';
import {uploadLocal, getLocal, deleteLocal, pingLocal} from './local';
@@ -46,7 +46,7 @@ const handlers: Record<StorageProviderKind, ProviderHandler> = {
export async function dispatchViaProvider(
kind: StorageProviderKind,
config: any,
input: StorageInput
input: StorageInput,
): Promise<StorageResult> {
const provider = handlers[kind];
src/features/storages/providers/local.ts
+40 -24
View File
@@ -1,15 +1,16 @@
"use server"
import {mkdir, writeFile, unlink, readFile} from 'fs/promises';
import path from 'path';
import {StorageDeleteInput, StorageGetInput, StorageResult, StorageUploadInput} from '../types';
import {StorageDeleteInput, StorageGetInput, StorageMetaData, StorageResult, StorageUploadInput} from '../types';
import fs from "node:fs";
import {getServerUrl} from "@/utils/get-server-url";
import {generateFileUrl} from "@/features/storages/helpers";
const BASE_DIR = "/private/uploads/";
export async function uploadLocal(
config: { baseDir?: string },
input: { data: StorageUploadInput }
input: { data: StorageUploadInput, metadata?: StorageMetaData }
): Promise<StorageResult> {
const base = config.baseDir || BASE_DIR;
const fullPath = path.join(process.cwd(), base, input.data.path);
@@ -18,18 +19,35 @@ export async function uploadLocal(
await mkdir(dir, {recursive: true});
await writeFile(fullPath, input.data.file);
const baseUrl = getServerUrl();
if (input.data.url) {
const url = await generateFileUrl(input);
if (!url) {
return {
success: false,
provider: "local",
response: "Unable to get url file"
};
}
return {
success: true,
provider: 'local',
url: url
};
}
return {
success: true,
provider: 'local',
url: `${baseUrl}/api/${input.data.path}`,
};
}
export async function getLocal(
config: { baseDir?: string },
input: { data: StorageGetInput }
input: { data: StorageGetInput, metadata: StorageMetaData }
): Promise<StorageResult> {
const base = config.baseDir || BASE_DIR;
const filePath = path.join(process.cwd(), base, input.data.path)
@@ -46,37 +64,35 @@ export async function getLocal(
}
if (input.data.signedUrl) {
const crypto = require("crypto");
const baseUrl = getServerUrl();
const url = await generateFileUrl(input);
const expiresAt = Date.now() + 60 * 1000;
const token = crypto.createHash("sha256").update(`${fileName}${expiresAt}`).digest("hex");
const params = new URLSearchParams({
path: input.data.path,
token,
expires: expiresAt.toString(),
});
if (!url) {
return {
success: false,
provider: "local",
response: "Unable to get url file"
};
}
return {
success: true,
provider: 'local',
file: file,
url: `${baseUrl}/api/files/?${params.toString()}`,
};
} else {
return {
success: true,
provider: 'local',
provider: "local",
file: file,
url: url,
};
}
return {
success: true,
provider: "local",
file: file,
};
}
export async function deleteLocal(
config: { baseDir?: string },
input: { data: StorageDeleteInput }
input: { data: StorageDeleteInput, metadata?: StorageMetaData }
): Promise<StorageResult> {
const base = config.baseDir || BASE_DIR;
const fullPath = path.join(process.cwd(), base, input.data.path);
src/features/storages/types.ts
+13 -3
View File
@@ -9,9 +9,19 @@ export type StorageAction =
| 'get'
| 'delete';
export type StorageFileKind =
| 'backups'
| 'images'
export type StorageMetaData = {
storageId: string,
fileKind: StorageFileKind
}
export interface StorageUploadInput {
path: string;
file: Buffer | Uint8Array;
url?: boolean;
contentType?: string;
}
@@ -26,9 +36,9 @@ export interface StorageDeleteInput {
}
export type StorageInput =
| { action: 'upload'; data: StorageUploadInput }
| { action: 'get'; data: StorageGetInput }
| { action: 'delete'; data: StorageDeleteInput }
| { action: 'upload'; data: StorageUploadInput, metadata?: StorageMetaData }
| { action: 'get'; data: StorageGetInput, metadata: StorageMetaData}
| { action: 'delete'; data: StorageDeleteInput, metadata?: StorageMetaData }
| { action: 'ping'; };
export interface StorageResult {
src/features/upload/public/upload.action.ts
+7 -1
View File
@@ -45,11 +45,17 @@ export const uploadUserImageAction = userAction.schema(
action: "upload",
data: {
path: path,
file: buffer
file: buffer,
url: true
},
metadata: {
storageId: settings.storageChannel.id,
fileKind: "images"
}
}
const result = await dispatchStorage(input, undefined, settings.storageChannel.id);
console.log(result);
if (!result.success) {
return {
success: false,