@tulip-systems/core 0.8.2 → 0.9.0

package/dist/src/modules/inline/lib/variants.mjs

@@ -0,0 +1,21 @@
+import { cva } from "class-variance-authority";
+
+//#region src/modules/inline/lib/variants.ts
+const inlineEditVariants = cva("", {
+	variants: {
+		variant: {
+			default: "",
+			table: "min-h-8 px-3 py-1 text-base md:text-sm rounded-none h-full w-full border-none outline-none ring-0 focus:border-0 focus:outline-none focus:ring-0 focus:ring-offset-0 focus-visible:outline-none focus-visible:ring-0 focus-visible:ring-offset-0"
+		},
+		status: {
+			idle: "",
+			pending: "opacity-70 animate-pulse",
+			success: "",
+			error: "border-destructive text-destructive"
+		}
+	},
+	defaultVariants: { variant: "default" }
+});
+
+//#endregion
+export { inlineEditVariants };

package/dist/src/modules/router/handler/caller.client.d.mts

@@ -0,0 +1,10 @@
+import { RouterClient as RouterClient$1 } from "./register.server.mjs";
+import { AnyRouter } from "@orpc/server";
+
+//#region src/modules/router/handler/caller.client.d.ts
+/**
+ * Create a new RPC client
+ */
+declare function createRPCClient<TRouter extends AnyRouter>(): RouterClient$1<TRouter>;
+//#endregion
+export { createRPCClient };

package/dist/src/modules/router/handler/caller.client.mjs

@@ -0,0 +1,23 @@
+"use client";
+
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+
+//#region src/modules/router/handler/caller.client.tsx
+/**
+* Create a new RPC client
+*/
+const client = createORPCClient(new RPCLink({ url: () => {
+	if (typeof window === "undefined") throw new Error("RPCLink is not allowed on the server side.");
+	return `${window.location.origin}/api/rpc`;
+} }));
+/**
+* Create a new RPC client
+*/
+function createRPCClient() {
+	return createTanstackQueryUtils(client);
+}
+
+//#endregion
+export { createRPCClient };

package/dist/src/modules/router/handler/caller.server.d.mts

@@ -0,0 +1,6 @@
+import { createRouterClient } from "@orpc/server";
+
+//#region src/modules/router/handler/caller.server.d.ts
+declare const createRPCCaller: typeof createRouterClient;
+//#endregion
+export { createRPCCaller };

package/dist/src/modules/router/handler/caller.server.mjs

@@ -0,0 +1,7 @@
+import { createRouterClient } from "@orpc/server";
+
+//#region src/modules/router/handler/caller.server.ts
+const createRPCCaller = createRouterClient;
+
+//#endregion
+export { createRPCCaller };

package/dist/src/modules/router/handler/context.server.d.mts

@@ -0,0 +1,62 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { Database } from "../../database/lib/service.server.mjs";
+import "../../../../database/server.mjs";
+import { Email } from "../../emails/lib/service.server.mjs";
+import { Auth } from "../../auth/handler/service.server.mjs";
+import { Storage } from "../../storage/lib/service.server.mjs";
+import { TulipContext } from "../../config/lib/context.mjs";
+import "../../../../config.mjs";
+import "../../../../auth/server.mjs";
+import "../../../../emails/server.mjs";
+import "../../../../storage/server.mjs";
+import "server-cli-only";
+import * as next_dist_server_web_spec_extension_adapters_headers0 from "next/dist/server/web/spec-extension/adapters/headers";
+
+//#region src/modules/router/handler/context.server.d.ts
+/**
+ * Create the router context
+ */
+declare const createRPCContext: <TSchema extends TDatabaseSchema>(props: {
+  context: TulipContext<TSchema>;
+}) => Promise<{
+  session: {
+    session: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      userId: string;
+      expiresAt: Date;
+      token: string;
+      ipAddress?: string | null | undefined | undefined;
+      userAgent?: string | null | undefined | undefined;
+      impersonatedBy?: string | null | undefined;
+    };
+    user: {
+      id: string;
+      createdAt: Date;
+      updatedAt: Date;
+      email: string;
+      emailVerified: boolean;
+      name: string;
+      image?: string | null | undefined | undefined;
+      firstName: string;
+      lastName: string;
+      banned: boolean | null | undefined;
+      role?: string | null | undefined;
+      banReason?: string | null | undefined;
+      banExpires?: Date | null | undefined;
+    };
+  } | null;
+  headers: next_dist_server_web_spec_extension_adapters_headers0.ReadonlyHeaders;
+  db: Database<TSchema>;
+  schema: TSchema;
+  auth: Auth;
+  email: Email;
+  storage: Storage<TSchema>;
+}>;
+type RPCContext<TSchema extends TDatabaseSchema = any> = Awaited<ReturnType<typeof createRPCContext<TSchema>>>;
+type ProtectedRPCContext<TSchema extends TDatabaseSchema = any> = RPCContext<TSchema> & {
+  session: NonNullable<RPCContext<TSchema>["session"]>;
+};
+//#endregion
+export { ProtectedRPCContext, RPCContext, createRPCContext };

package/dist/src/modules/router/handler/context.server.mjs

@@ -0,0 +1,20 @@
+import { cache } from "react";
+import "server-cli-only";
+import { headers } from "next/headers";
+
+//#region src/modules/router/handler/context.server.ts
+/**
+* Create the router context
+*/
+const createRPCContext = cache(async (props) => {
+	const headers$1 = await headers();
+	const session = await props.context.auth.api.getSession({ headers: headers$1 });
+	return {
+		...props.context,
+		session,
+		headers: headers$1
+	};
+});
+
+//#endregion
+export { createRPCContext };

package/dist/src/modules/router/handler/init.server.d.mts

@@ -0,0 +1,65 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { Database } from "../../database/lib/service.server.mjs";
+import "../../../../database/server.mjs";
+import { Email } from "../../emails/lib/service.server.mjs";
+import { Auth } from "../../auth/handler/service.server.mjs";
+import { Storage } from "../../storage/lib/service.server.mjs";
+import "../../../../auth/server.mjs";
+import "../../../../emails/server.mjs";
+import "../../../../storage/server.mjs";
+import { ProtectedRPCContext, RPCContext } from "./context.server.mjs";
+import * as _orpc_server0 from "@orpc/server";
+import "server-cli-only";
+import * as next_dist_server_web_spec_extension_adapters_headers0 from "next/dist/server/web/spec-extension/adapters/headers";
+import * as _orpc_contract0 from "@orpc/contract";
+
+//#region src/modules/router/handler/init.server.d.ts
+/**
+ * Initialize TRPC
+ */
+declare function initRPC<TSchema extends TDatabaseSchema>(): {
+  publicProcedure: _orpc_server0.Builder<RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema>, _orpc_contract0.Schema<unknown, unknown>, _orpc_contract0.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+  protectedProcedure: _orpc_server0.BuilderWithMiddlewares<_orpc_server0.MergedInitialContext<RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema> & Record<never, never>, RPCContext<TSchema>>, _orpc_server0.MergedCurrentContext<RPCContext<TSchema>, ProtectedRPCContext<TSchema>>, _orpc_contract0.Schema<unknown, unknown>, _orpc_contract0.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+  authMiddleware: _orpc_server0.DecoratedMiddleware<RPCContext<TSchema> & Record<never, never>, ProtectedRPCContext<TSchema>, unknown, any, any, Record<never, never>>;
+  permissionMiddleware: (permissions: Permission) => _orpc_server0.DecoratedMiddleware<{
+    session: {
+      session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined | undefined;
+        userAgent?: string | null | undefined | undefined;
+        impersonatedBy?: string | null | undefined;
+      };
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined | undefined;
+        firstName: string;
+        lastName: string;
+        banned: boolean | null | undefined;
+        role?: string | null | undefined;
+        banReason?: string | null | undefined;
+        banExpires?: Date | null | undefined;
+      };
+    } | null;
+    headers: next_dist_server_web_spec_extension_adapters_headers0.ReadonlyHeaders;
+    db: Database<TSchema>;
+    schema: TSchema;
+    auth: Auth;
+    email: Email;
+    storage: Storage<TSchema>;
+  } & {
+    session: NonNullable<RPCContext<TSchema_1>["session"]>;
+  } & Record<never, never>, ProtectedRPCContext<TSchema>, unknown, any, any, Record<never, never>>;
+};
+//#endregion
+export { initRPC };

package/dist/src/modules/router/handler/init.server.mjs

@@ -0,0 +1,55 @@
+import { ServerError } from "../lib/error.server.mjs";
+import { os } from "@orpc/server";
+import "server-cli-only";
+
+//#region src/modules/router/handler/init.server.ts
+/**
+* Initialize TRPC
+*/
+function initRPC() {
+	/**
+	* Create the router
+	*/
+	const o = os.$context();
+	/**
+	* Middleware function to check if the user is authenticated
+	*/
+	const authMiddleware = o.middleware(async (opts) => {
+		if (!opts.context.session) throw new ServerError("UNAUTHORIZED", { message: "Jou hebt geen toegang om deze actie uit te voeren" });
+		return opts.next({ context: {
+			...opts.context,
+			session: opts.context.session
+		} });
+	});
+	/**
+	* Middleware function to check if the user has the required permission
+	*/
+	function permissionMiddleware(permissions) {
+		/**
+		* Middleware function to check if the user has the required permission
+		*/
+		return os.$context().middleware(async (opts) => {
+			const { success, error } = await opts.context.auth.api.userHasPermission({
+				headers: opts.context.headers,
+				body: {
+					userId: opts.context.session.user.id,
+					permissions
+				}
+			});
+			if (error || !success) throw new ServerError("UNAUTHORIZED", { message: "Jou hebt geen toegang om deze actie uit te voeren" });
+			return opts.next({ context: { ...opts.context } });
+		});
+	}
+	/**
+	* Export
+	*/
+	return {
+		publicProcedure: o,
+		protectedProcedure: o.use(authMiddleware),
+		authMiddleware,
+		permissionMiddleware
+	};
+}
+
+//#endregion
+export { initRPC };

package/dist/src/modules/router/handler/register.server.d.mts

@@ -0,0 +1,8 @@
+import { AnyRouter, RouterClient } from "@orpc/server";
+import { RouterUtils } from "@orpc/tanstack-query";
+
+//#region src/modules/router/handler/register.server.d.ts
+type RouterClient$1<TRouter extends AnyRouter> = RouterUtils<RouterClient<TRouter>>;
+declare function registerRouterClient<TRouter extends AnyRouter>(client: RouterClient<TRouter>): any;
+//#endregion
+export { RouterClient$1 as RouterClient, registerRouterClient };

package/dist/src/modules/router/handler/register.server.mjs

@@ -0,0 +1,10 @@
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+
+//#region src/modules/router/handler/register.server.ts
+function registerRouterClient(client) {
+	if (!globalThis.$client) globalThis.$client = createTanstackQueryUtils(client);
+	return globalThis.$client;
+}
+
+//#endregion
+export { registerRouterClient };

package/dist/src/modules/router/handler/route.server.d.mts

@@ -0,0 +1,21 @@
+import { TDatabaseSchema } from "../../database/lib/types.mjs";
+import { TulipContext } from "../../config/lib/context.mjs";
+import { AnyRouter } from "@orpc/server";
+
+//#region src/modules/router/handler/route.server.d.ts
+/**
+ * RPC Route handler
+ */
+declare function handleRPCRoute<TRouter extends AnyRouter, TSchema extends TDatabaseSchema>(props: {
+  appRouter: TRouter;
+  context: TulipContext<TSchema>;
+}): {
+  HEAD: (request: Request) => Promise<Response>;
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+  PUT: (request: Request) => Promise<Response>;
+  PATCH: (request: Request) => Promise<Response>;
+  DELETE: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { handleRPCRoute };

package/dist/src/modules/router/handler/route.server.mjs

@@ -0,0 +1,32 @@
+import { createRPCContext } from "./context.server.mjs";
+import { onError } from "@orpc/client";
+import { RPCHandler } from "@orpc/server/fetch";
+
+//#region src/modules/router/handler/route.server.ts
+/**
+* RPC Route handler
+*/
+function handleRPCRoute(props) {
+	const handler = new RPCHandler(props.appRouter, { interceptors: [onError((error) => {
+		console.error(JSON.stringify(error));
+	})] });
+	async function handleRequest(request) {
+		const rpcContext = await createRPCContext({ context: props.context });
+		const { response } = await handler.handle(request, {
+			prefix: "/api/rpc",
+			context: rpcContext
+		});
+		return response ?? new Response("Not found", { status: 404 });
+	}
+	return {
+		HEAD: handleRequest,
+		GET: handleRequest,
+		POST: handleRequest,
+		PUT: handleRequest,
+		PATCH: handleRequest,
+		DELETE: handleRequest
+	};
+}
+
+//#endregion
+export { handleRPCRoute };

package/dist/src/modules/router/lib/error.server.d.mts

@@ -0,0 +1,2 @@
+import { ORPCError as ServerError } from "@orpc/server";
+export { ServerError };

package/dist/src/modules/router/lib/error.server.mjs

@@ -0,0 +1,3 @@
+import { ORPCError as ServerError } from "@orpc/server";
+
+export { ServerError };

package/dist/src/modules/router/lib/helpers.mjs

@@ -0,0 +1,7 @@
+import { StandardRPCJsonSerializer } from "@orpc/client/standard";
+
+//#region src/modules/router/lib/helpers.ts
+const serializer = new StandardRPCJsonSerializer();
+
+//#endregion
+export { serializer };

package/dist/src/modules/router/lib/query-client.d.mts

@@ -0,0 +1,9 @@
+import { QueryClient } from "@tanstack/react-query";
+
+//#region src/modules/router/lib/query-client.d.ts
+/**
+ * Create a new query client
+ */
+declare function createQueryClient(): QueryClient;
+//#endregion
+export { createQueryClient };

package/dist/src/modules/router/lib/query-client.mjs

@@ -0,0 +1,50 @@
+import { serializer } from "./helpers.mjs";
+import { MutationCache, QueryClient, isServer } from "@tanstack/react-query";
+
+//#region src/modules/router/lib/query-client.ts
+/**
+* Create a new query client
+*/
+function createQueryClient() {
+	let queryClient;
+	queryClient = new QueryClient({
+		defaultOptions: {
+			queries: {
+				queryKeyHashFn(queryKey) {
+					const [json, meta] = serializer.serialize(queryKey);
+					return JSON.stringify({
+						json,
+						meta
+					});
+				},
+				staleTime: 60 * 1e3
+			},
+			dehydrate: { serializeData(data) {
+				const [json, meta] = serializer.serialize(data);
+				return {
+					json,
+					meta
+				};
+			} },
+			hydrate: { deserializeData(data) {
+				return serializer.deserialize(data.json, data.meta);
+			} }
+		},
+		mutationCache: new MutationCache({ onSuccess: () => {
+			queryClient.invalidateQueries();
+		} })
+	});
+	return queryClient;
+}
+/**
+*  Create a stable getter for the query client that will return the same client during the same request.
+*/
+let browserQueryClient;
+function getQueryClient() {
+	if (isServer) return createQueryClient();
+	if (!browserQueryClient) browserQueryClient = createQueryClient();
+	return browserQueryClient;
+}
+
+//#endregion
+export { createQueryClient, getQueryClient };

package/dist/src/modules/router/lib/query-client.server.d.mts

@@ -0,0 +1,17 @@
+import { createQueryClient } from "./query-client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import "server-cli-only";
+
+//#region src/modules/router/lib/query-client.server.d.ts
+/**
+ *  Create a stable getter for the query client that will return the same client during the same request.
+ */
+declare const getQueryClient: typeof createQueryClient;
+/**
+ * Hydrate the client with the data from the server
+ */
+declare function HydrateClient(props: {
+  children: React.ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { HydrateClient, getQueryClient };

package/dist/src/modules/router/lib/query-client.server.mjs

@@ -0,0 +1,23 @@
+import { createQueryClient } from "./query-client.mjs";
+import { jsx } from "react/jsx-runtime";
+import { cache } from "react";
+import { HydrationBoundary, dehydrate } from "@tanstack/react-query";
+import "server-cli-only";
+
+//#region src/modules/router/lib/query-client.server.tsx
+/**
+*  Create a stable getter for the query client that will return the same client during the same request.
+*/
+const getQueryClient = cache(createQueryClient);
+/**
+* Hydrate the client with the data from the server
+*/
+function HydrateClient(props) {
+	return /* @__PURE__ */ jsx(HydrationBoundary, {
+		state: dehydrate(getQueryClient()),
+		children: props.children
+	});
+}
+
+//#endregion
+export { HydrateClient, getQueryClient };

package/dist/src/modules/router/lib/validators.d.mts

@@ -0,0 +1,12 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/router/lib/validators.d.ts
+/**
+ * Bulk action schema
+ */
+declare const bulkActionSchema: z$1.ZodObject<{
+  ids: z$1.ZodArray<z$1.ZodString>;
+}, z$1.core.$strip>;
+type BulkActionSchema = z$1.infer<typeof bulkActionSchema>;
+//#endregion
+export { BulkActionSchema, bulkActionSchema };

package/dist/src/modules/router/lib/validators.mjs

@@ -0,0 +1,10 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/router/lib/validators.ts
+/**
+* Bulk action schema
+*/
+const bulkActionSchema = z$1.object({ ids: z$1.array(z$1.string()) });
+
+//#endregion
+export { bulkActionSchema };

package/dist/src/modules/storage/components/dropzone-context.client.d.mts

@@ -0,0 +1,18 @@
+import * as react from "react";
+import { DropzoneOptions } from "react-dropzone";
+
+//#region src/modules/storage/components/dropzone-context.client.d.ts
+type DropzoneContextType = {
+  src?: File[];
+  accept?: DropzoneOptions["accept"];
+  maxSize?: DropzoneOptions["maxSize"];
+  minSize?: DropzoneOptions["minSize"];
+  maxFiles?: DropzoneOptions["maxFiles"];
+};
+declare const DropzoneContext: react.Context<DropzoneContextType | undefined>;
+/**
+ * Dropzone context hook
+ */
+declare function useDropzoneContext(): DropzoneContextType;
+//#endregion
+export { DropzoneContext, useDropzoneContext };

package/dist/src/modules/storage/components/dropzone-context.client.mjs

@@ -0,0 +1,17 @@
+"use client";
+
+import { createContext, use } from "react";
+
+//#region src/modules/storage/components/dropzone-context.client.tsx
+const DropzoneContext = createContext(void 0);
+/**
+* Dropzone context hook
+*/
+function useDropzoneContext() {
+	const context = use(DropzoneContext);
+	if (!context) throw new Error("useDropzoneContext must be used within a Dropzone");
+	return context;
+}
+
+//#endregion
+export { DropzoneContext, useDropzoneContext };

package/dist/src/modules/storage/components/dropzone.client.d.mts

@@ -0,0 +1,52 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+import { ReactNode } from "react";
+import { DropEvent, DropzoneOptions, FileRejection } from "react-dropzone";
+
+//#region src/modules/storage/components/dropzone.client.d.ts
+/**
+ * Dropzone
+ */
+type DropzoneProps = Omit<DropzoneOptions, "onDrop"> & {
+  src?: File[];
+  className?: string;
+  onDrop?: (acceptedFiles: File[], fileRejections: FileRejection[], event: DropEvent) => void;
+  children?: ReactNode;
+};
+declare function Dropzone({
+  accept,
+  maxFiles,
+  maxSize,
+  minSize,
+  onDrop,
+  onError,
+  disabled,
+  src,
+  className,
+  children,
+  ...props
+}: DropzoneProps): react_jsx_runtime0.JSX.Element;
+/**
+ * DropzoneContent
+ */
+type DropzoneContentProps = {
+  children?: ReactNode;
+  className?: string;
+};
+declare function DropzoneContent({
+  children,
+  className
+}: DropzoneContentProps): string | number | bigint | true | react_jsx_runtime0.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+/**
+ * DropzoneEmptyState
+ */
+type DropzoneEmptyStateProps = {
+  children?: ReactNode;
+  className?: string;
+};
+declare function DropzoneEmptyState({
+  children,
+  className
+}: DropzoneEmptyStateProps): string | number | bigint | true | react_jsx_runtime0.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+//#endregion
+export { Dropzone, DropzoneContent, DropzoneContentProps, DropzoneEmptyState, DropzoneEmptyStateProps, DropzoneProps };