@tulip-systems/core 0.6.1 → 0.8.0

package/src/lib/config/constants.ts

@@ -1 +0,0 @@
-export const BUCKET_NAME = process.env.S3_BUCKET ?? "";

package/src/lib/utils/time-picker.ts

@@ -1,139 +0,0 @@
-/**
- * regular expression to check for valid hour format (01-23)
- */
-export function isValidHour(value: string) {
-  return /^(0[0-9]|1[0-9]|2[0-3])$/.test(value);
-}
-
-/**
- * regular expression to check for valid 12 hour format (01-12)
- */
-export function isValid12Hour(value: string) {
-  return /^(0[1-9]|1[0-2])$/.test(value);
-}
-
-/**
- * regular expression to check for valid minute format (00-59)
- */
-export function isValidMinuteOrSecond(value: string) {
-  return /^[0-5][0-9]$/.test(value);
-}
-
-type GetValidNumberConfig = { max: number; min?: number; loop?: boolean };
-
-export function getValidNumber(
-  value: string,
-  { max, min = 0, loop = false }: GetValidNumberConfig,
-) {
-  let numericValue = parseInt(value, 10);
-
-  if (!Number.isNaN(numericValue)) {
-    if (!loop) {
-      if (numericValue > max) numericValue = max;
-      if (numericValue < min) numericValue = min;
-    } else {
-      if (numericValue > max) numericValue = min;
-      if (numericValue < min) numericValue = max;
-    }
-    return numericValue.toString().padStart(2, "0");
-  }
-
-  return "00";
-}
-
-export function getValidHour(value: string) {
-  if (isValidHour(value)) return value;
-  return getValidNumber(value, { max: 23 });
-}
-
-export function getValid12Hour(value: string) {
-  if (isValid12Hour(value)) return value;
-  return getValidNumber(value, { max: 12 });
-}
-
-export function getValidMinuteOrSecond(value: string) {
-  if (isValidMinuteOrSecond(value)) return value;
-  return getValidNumber(value, { max: 59 });
-}
-
-type GetValidArrowNumberConfig = {
-  min: number;
-  max: number;
-  step: number;
-};
-
-export function getValidArrowNumber(value: string, { min, max, step }: GetValidArrowNumberConfig) {
-  let numericValue = parseInt(value, 10);
-  if (!Number.isNaN(numericValue)) {
-    numericValue += step;
-    return getValidNumber(String(numericValue), { min, max, loop: true });
-  }
-  return "00";
-}
-
-export function getValidArrowHour(value: string, step: number) {
-  return getValidArrowNumber(value, { min: 0, max: 23, step });
-}
-
-export function getValidArrowMinuteOrSecond(value: string, step: number) {
-  return getValidArrowNumber(value, { min: 0, max: 59, step });
-}
-
-export function setMinutes(date: Date, value: string) {
-  const minutes = getValidMinuteOrSecond(value);
-  date.setMinutes(parseInt(minutes, 10));
-  return date;
-}
-
-export function setSeconds(date: Date, value: string) {
-  const seconds = getValidMinuteOrSecond(value);
-  date.setSeconds(parseInt(seconds, 10));
-  return date;
-}
-
-export function setHours(date: Date, value: string) {
-  const hours = getValidHour(value);
-  date.setHours(parseInt(hours, 10));
-  return date;
-}
-
-export type TimePickerType = "minutes" | "seconds" | "hours"; // | "12hours";
-
-export function setDateByType(date: Date, value: string, type: TimePickerType) {
-  switch (type) {
-    case "minutes":
-      return setMinutes(date, value);
-    case "seconds":
-      return setSeconds(date, value);
-    case "hours":
-      return setHours(date, value);
-    default:
-      return date;
-  }
-}
-
-export function getDateByType(date: Date, type: TimePickerType) {
-  switch (type) {
-    case "minutes":
-      return getValidMinuteOrSecond(String(date.getMinutes()));
-    case "seconds":
-      return getValidMinuteOrSecond(String(date.getSeconds()));
-    case "hours":
-      return getValidHour(String(date.getHours()));
-    default:
-      return "00";
-  }
-}
-
-export function getArrowByType(value: string, step: number, type: TimePickerType) {
-  switch (type) {
-    case "minutes":
-      return getValidArrowMinuteOrSecond(value, step);
-    case "seconds":
-      return getValidArrowMinuteOrSecond(value, step);
-    case "hours":
-      return getValidArrowHour(value, step);
-    default:
-      return "00";
-  }
-}

package/src/modules/config/db/init.ts

@@ -1,21 +0,0 @@
-import "server-cli-only";
-
-import { drizzle } from "drizzle-orm/node-postgres";
-import type { Pool } from "pg";
-import type { TDatabaseSchema } from "./types";
-
-type InitDatabaseProps<TSchema extends TDatabaseSchema> = {
-  schema: TSchema;
-  pool: Pool;
-};
-
-export function initDatabase<TSchema extends TDatabaseSchema>({
-  schema,
-  pool,
-}: InitDatabaseProps<TSchema>) {
-  return drizzle({ client: pool, schema, casing: "snake_case" });
-}
-
-export type DatabaseClient<TSchema extends TDatabaseSchema> = ReturnType<
-  typeof initDatabase<TSchema>
->;

package/src/modules/config/providers/email.ts

@@ -1,13 +0,0 @@
-import "server-cli-only";
-
-import { Resend } from "resend";
-
-type InitEmailProviderProps = {
-  key: string;
-};
-
-export function initEmailProvider(props: InitEmailProviderProps) {
-  return new Resend(props.key);
-}
-
-export type EmailClient = ReturnType<typeof initEmailProvider>;

package/src/modules/storage/config/filters.ts

@@ -1,12 +0,0 @@
-import z from "zod";
-import { createTableFilters } from "@/modules/data-tables/lib/filters/config";
-import { parseFilterArray, parseFilterBoolean } from "@/modules/data-tables/lib/filters/parsers";
-import { nodeTypeEnum } from "../lib/schema";
-
-export const nodesTableFilters = createTableFilters({
-  types: parseFilterArray(z.array(z.enum(nodeTypeEnum.enumValues))),
-  nodeIds: parseFilterArray(z.array(z.string())),
-  isDeleted: parseFilterBoolean(z.boolean()),
-  isOrphaned: parseFilterBoolean(z.boolean()),
-  hidden: parseFilterBoolean(z.boolean()),
-});

package/src/modules/storage/lib/create-client.server.ts

@@ -1,14 +0,0 @@
-import "server-cli-only";
-
-import type { TDatabaseSchema } from "@/modules/config/entry";
-import { StorageService, type StorageServiceConfig } from "./service.server";
-
-export function createStorageClient<TSchema extends TDatabaseSchema>(
-  props: StorageServiceConfig<TSchema>,
-) {
-  return new StorageService(props);
-}
-
-export type StorageClient<TSchema extends TDatabaseSchema> = ReturnType<
-  typeof createStorageClient<TSchema>
->;

package/src/modules/storage/lib/create-upload.client.ts

@@ -1,134 +0,0 @@
-import { generateDefaultUUID } from "@/modules/config/entry";
-import type { BulkActionSchema } from "@/modules/router/entry";
-import type { PresignFileSchema, SelectNodeSchema, UpdateNodeSchema } from "./validators";
-
-/**
- * Upload request
- */
-export type PrepareUploadInput = Omit<UploadFileRequest, "id" | "name" | "size" | "contentType">;
-export type UploadFileRequest = PresignFileSchema & { file: File };
-export type UploadHooks = {
-  beforePresign?: (input: UploadFileRequest) => Promise<void> | void;
-  afterPresign?: (presignResult: { id: string; presignedUrl: string }) => Promise<void> | void;
-  beforeConfirm?: (presignResult: { id: string; presignedUrl: string }) => Promise<void> | void;
-  afterConfirm?: (node: SelectNodeSchema) => Promise<void> | void;
-};
-
-/**
- * Upload client
- */
-export type UploadClient = {
-  prepareUpload: (input: PrepareUploadInput) => UploadFileRequest;
-  upload: (input: UploadFileRequest, hooks?: UploadHooks) => Promise<SelectNodeSchema>;
-  deleteFiles: (ids: string[]) => Promise<void>;
-  updateNode: (id: string, data: UpdateNodeSchema) => Promise<SelectNodeSchema>;
-};
-
-/**
- * Create upload client
- */
-type CreateUploadClientProps = {
-  endpoints: {
-    presign: (input: PresignFileSchema) => Promise<{ id: string; presignedUrl: string }>;
-    confirm: (input: { id: string }) => Promise<SelectNodeSchema>;
-    deleteNodes: (input: BulkActionSchema) => Promise<void>;
-    updateNode: (input: { id: string; data: UpdateNodeSchema }) => Promise<SelectNodeSchema>;
-  };
-};
-
-export function createUploadClient(props: CreateUploadClientProps): UploadClient {
-  /**
-   * Create input schema for the upload method
-   * @param {PrepareUploadInput} input
-   * @returns {UploadFileRequest}
-   */
-  function prepareUpload(input: PrepareUploadInput): UploadFileRequest {
-    return {
-      ...input,
-      id: generateDefaultUUID(),
-      name: input.file.name,
-      size: input.file.size,
-      contentType: input.file.type,
-    };
-  }
-
-  /**
-   * Upload file to the server
-   * @param {UploadFileRequest} input
-   * @returns {Promise<SelectNodeSchema>}
-   */
-  async function upload(input: UploadFileRequest, hooks?: UploadHooks): Promise<SelectNodeSchema> {
-    try {
-      /**
-       * Presign
-       */
-      await hooks?.beforePresign?.(input);
-      const presignResult = await props.endpoints.presign(input);
-      await hooks?.afterPresign?.(presignResult);
-      /**
-       * Upload the file
-       */
-      const uploadResponse = await fetch(presignResult.presignedUrl, {
-        method: "PUT",
-        headers: { "Content-Type": input.file.type },
-        body: input.file,
-      });
-
-      if (!uploadResponse.ok) {
-        const message = await uploadResponse.text();
-        throw new Error(`Upload failed: ${message}`);
-      }
-
-      /**
-       * Confirm
-       */
-      await hooks?.beforeConfirm?.(presignResult);
-      const node = await props.endpoints.confirm({ id: presignResult.id });
-      await hooks?.afterConfirm?.(node);
-      /**
-       * Return
-       */
-      return node;
-    } catch (err) {
-      console.error("Upload error: ", err);
-
-      /**
-       * Delete if upload failed
-       * */
-      try {
-        await deleteFiles([input.id]);
-      } catch (cleanupErr) {
-        console.error("Cleanup delete failed:", cleanupErr);
-      }
-
-      throw err;
-    }
-  }
-
-  /**
-   * Delete files
-   * @param {string[]} ids
-   */
-  async function deleteFiles(ids: string[]) {
-    await props.endpoints.deleteNodes({ ids });
-  }
-
-  /**
-   * Update node
-   * @param {string} id
-   * @param {UpdateNodeSchema} data
-   */
-  async function updateNode(id: string, data: UpdateNodeSchema) {
-    return props.endpoints.updateNode({ id, data });
-  }
-
-  /**
-   * Upload client
-   */
-  return {
-    prepareUpload,
-    upload,
-    deleteFiles,
-    updateNode,
-  };
-}

package/src/modules/storage/lib/proxy.server.ts

@@ -1,63 +0,0 @@
-import "server-cli-only";
-
-import { eq } from "drizzle-orm";
-import { connection, type NextRequest } from "next/server";
-import { getSession } from "@/modules/auth/entry.server";
-import type { TulipContext } from "@/modules/config/entry";
-import { type DriveSchema, nodes } from "./schema";
-import { getFileURLSchema } from "./validators";
-
-type CreateDriveProxyRouteProps<TSchema extends DriveSchema> = {
-  context: TulipContext<TSchema>;
-};
-
-/**
- * Create drive proxy route
- */
-export function createDriveProxyRoute<TSchema extends DriveSchema>({
-  context,
-}: CreateDriveProxyRouteProps<TSchema>) {
-  /**
-   * GET: Drive node proxy
-   */
-  async function GET(request: NextRequest) {
-    // Make endpoint dynamic
-    await connection();
-
-    try {
-      // Get the params
-      const searchParams = request.nextUrl.searchParams;
-      const id = searchParams.get("id");
-      if (!id) return Response.json("Missing id", { status: 400 });
-
-      console.info("Proxying file: ", id);
-
-      // Get the node
-      const [node] = await context.db.select().from(nodes).where(eq(nodes.id, id));
-      if (!node) return Response.json("Bestand kon niet worden gevonden", { status: 404 });
-
-      // If the node is private check if the user is authenticated
-      if (node.mode === "private") {
-        const session = await getSession(context);
-        if (!session) return Response.json("Unauthorized", { status: 401 });
-      }
-
-      const variant = searchParams.get("variant") ?? undefined;
-      const disposition = searchParams.get("disposition") ?? undefined;
-
-      // Parse the options
-      const options = getFileURLSchema.parse({ variant, disposition });
-
-      // Get the file url
-      const url = await context.storage.getSignedURL(node, options);
-
-      // Return the file
-      return Response.redirect(url, 307);
-    } catch (error) {
-      console.error("error", error);
-      return Response.json("Error", { status: 500 });
-    }
-  }
-
-  return { GET };
-}

package/src/modules/storage/lib/router.server.ts

@@ -1,182 +0,0 @@
-import { and, eq, sql } from "drizzle-orm";
-import type { QueryResult } from "pg";
-import { z } from "zod";
-import { bulkActionSchema } from "@/modules/router/entry";
-import { ServerError } from "@/modules/router/entry.server";
-import { initRPC } from "@/modules/router/handler/init.server";
-import { isFolder } from "./helpers";
-import { type DriveSchema, nodes } from "./schema";
-import {
-  createFolderNodeSchema,
-  getFileURLSchema,
-  getNodesByParentIdSchema,
-  type Node,
-  presignFileSchema,
-  selectNodeSchema,
-  selectNodeWithChildrenSchema,
-  updateNodeSchema,
-} from "./validators";
-
-/**
- * Create Drive base procedures
- */
-export function createDriveBaseProcedures() {
-  const { protectedProcedure } = initRPC<DriveSchema>();
-
-  return {
-    /**
-     * Get node and its children
-     */
-    getNodeById: protectedProcedure
-      .input(z.object({ id: z.string(), namespace: z.string() }))
-      .output(selectNodeWithChildrenSchema.optional())
-      .handler(async ({ context, input }) =>
-        context.db.query.nodes.findFirst({
-          where: and(eq(nodes.id, input.id), eq(nodes.namespace, input.namespace)),
-          with: { children: true },
-        }),
-      ),
-    /**
-     * Get folders by parent id
-     */
-    getNodesByParentId: protectedProcedure
-      .input(getNodesByParentIdSchema)
-      .output(z.array(selectNodeSchema))
-      .handler(async ({ context, input }) => context.storage.getNodesByParentId(input)),
-    /**
-     * Get parents of a folder
-     */
-    getFolderParents: protectedProcedure
-      .input(z.object({ id: z.string().nullable(), namespace: z.string() }))
-      .handler(async ({ context, input }) => {
-        if (!input.id) return [];
-
-        const startNodeQuery = context.db
-          .select({
-            id: nodes.id,
-            name: nodes.name,
-            parentId: nodes.parentId,
-            depth: sql<number>`0`.as("depth"),
-          })
-          .from(nodes)
-          .where(and(eq(nodes.id, input.id), eq(nodes.namespace, input.namespace)));
-
-        const alias = "parent_nodes";
-        const parentNodesQueryAlias = startNodeQuery.as(alias);
-        const recursiveQueryName = sql.raw(`"${alias}"`);
-
-        const recursiveQuery = startNodeQuery.unionAll(
-          context.db
-            .select({
-              id: nodes.id,
-              name: nodes.name,
-              parentId: nodes.parentId,
-              depth: sql<number>`${parentNodesQueryAlias.depth} + 1`,
-            })
-            .from(nodes)
-            .innerJoin(recursiveQueryName, eq(nodes.id, parentNodesQueryAlias.parentId)),
-        );
-
-        const result = (await context.db.execute(
-          sql`WITH RECURSIVE ${recursiveQueryName} AS ${recursiveQuery} SELECT * FROM ${recursiveQueryName}`,
-        )) as QueryResult<Pick<Node, "id" | "name" | "parentId"> & { depth: number }>;
-
-        return result?.rows?.toSorted((a, b) => Number(b.depth) - Number(a.depth)) ?? [];
-      }),
-    /**
-     * Get presigned url for opening a file
-     */
-    getSignedURL: protectedProcedure
-      .input(getFileURLSchema.extend({ id: z.string() }))
-      .output(z.string().nullable())
-      .handler(async ({ context, input: { id, ...options } }) => {
-        const [node] = await context.db.select().from(nodes).where(eq(nodes.id, id));
-        if (!node) return null;
-
-        return await context.storage.getSignedURL(node, options);
-      }),
-
-    /**
-     * Get presigned url for uploading a file
-     */
-    presign: protectedProcedure
-      .input(presignFileSchema)
-      .output(z.object({ id: z.string(), presignedUrl: z.string() }))
-      .handler(async ({ context, input }) => context.storage.presignUpload(input)),
-    /**
-     * Confirm the upload
-     */
-    confirm: protectedProcedure
-      .input(z.object({ id: z.string() }))
-      .output(selectNodeSchema)
-      .handler(async ({ context, input }) => context.storage.confirmUpload(input)),
-    /**
-     * Create a folder
-     */
-    createFolder: protectedProcedure
-      .input(createFolderNodeSchema)
-      .output(selectNodeSchema)
-      .handler(async ({ context, input }) => context.storage.createFolder(input)),
-    /**
-     * Update node
-     */
-    updateNode: protectedProcedure
-      .input(z.object({ id: z.string(), data: updateNodeSchema }))
-      .output(selectNodeSchema)
-      .handler(async ({ context, input }) => context.storage.updateNode(input)),
-    /**
-     * Change node parent
-     */
-    changeParent: protectedProcedure
-      .input(z.object({ id: z.string(), parentId: z.string().nullish() }))
-      .handler(async ({ context, input }) => {
-        const [parent, node] = await Promise.all([
-          input.parentId &&
-            (await context.db.query.nodes.findFirst({
-              where: eq(nodes.id, input.parentId),
-            })),
-          context.db.query.nodes.findFirst({
-            where: eq(nodes.id, input.id),
-          }),
-        ]);
-
-        /**
-         * Validate
-         */
-        if (node?.readonly) {
-          throw new ServerError("BAD_REQUEST", {
-            message: "Deze node is alleen leesbaar en kan niet worden gewijzigd",
-          });
-        }
-
-        if (input.parentId && !parent)
-          throw new ServerError("BAD_REQUEST", { message: "Parent not found" });
-        if (!node) throw new ServerError("BAD_REQUEST", { message: "Node not found" });
-
-        if (parent && !isFolder(parent)) {
-          throw new ServerError("BAD_REQUEST", { message: "Parent is not a folder" });
-        }
-
-        if (parent && parent.namespace !== node.namespace) {
-          throw new ServerError("BAD_REQUEST", {
-            message: "Parent is not in the same namespace",
-          });
-        }
-
-        /**
-         * Update the parent
-         */
-        await context.db
-          .update(nodes)
-          .set({ parentId: input.parentId })
-          .where(eq(nodes.id, input.id));
-      }),
-    /**
-     * Delete nodes
-     */
-    deleteNodes: protectedProcedure
-      .input(bulkActionSchema)
-      .output(z.void())
-      .handler(async ({ context, input }) => context.storage.deleteNodes(input)),
-  };
-}