@tulip-systems/core 0.8.3 → 0.10.0

package/dist/src/modules/inline/hooks/use-inline.client.d.mts

@@ -0,0 +1,144 @@
+import { Permission } from "../../auth/lib/permissions.mjs";
+import { useInlineState } from "./inline-state.client.mjs";
+import { z as z$1 } from "zod";
+import { DefaultError, MutationOptions } from "@tanstack/react-query";
+
+//#region src/modules/inline/hooks/use-inline.client.d.ts
+type InlineTrigger = "change" | "blur" | "commit";
+type MutationConfig<TAllowedTrigger extends InlineTrigger> = {
+  on: TAllowedTrigger;
+  debounceMs?: number;
+};
+type InlineStrategy<TSchema extends z$1.ZodType, TAllowedTrigger extends InlineTrigger> = {
+  validate?: Partial<Record<TAllowedTrigger, TSchema>>;
+  mutate: MutationConfig<TAllowedTrigger>;
+};
+/**
+ * Use the inline edit hook options.
+ */
+type useInlineEditOptions<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  /**
+   * Initial value
+   */
+  initialValue?: z$1.input<TSchema>;
+  /**
+   * Transform validated schema value to mutation variables
+   */
+  variables?: (value: z$1.output<TSchema>) => TVariables;
+  /**
+   * Mutation options to execute on update
+   */
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  /**
+   * Permission required to edit
+   */
+  permission?: Permission;
+  /**
+   * Disable inline editing
+   */
+  disabled?: boolean;
+  /**
+   * Trigger-based strategy
+   */
+  strategy: InlineStrategy<TSchema, TAllowedTrigger>;
+};
+/**
+ * Inline edit hook props
+ */
+type UseInlineEditProps<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = useInlineEditOptions<TAllowedTrigger, TSchema, TData, TError, TVariables, TOnMutateResult> & {
+  parser: {
+    /**
+     * Transform the value from the result type to the value type
+     */
+    decode: (value: z$1.input<TSchema>) => TValue;
+    /**
+     * Transform the value from the value type to the result type
+     */
+    encode: (value: TValue) => z$1.input<TSchema>;
+  };
+};
+/**
+ * Resolves access and disabled state for inline editing.
+ *
+ * Responsibilities:
+ * - Merge local `permission`/`disabled` with provider-level config
+ * - Evaluate authorization via `usePermission`
+ * - Return `isAllowed` and final `isDisabled`
+ */
+type UseInlineAccessProps = {
+  permission?: Permission;
+  disabled?: boolean;
+};
+declare function useInlineAccess({
+  permission,
+  disabled
+}: UseInlineAccessProps): {
+  isAllowed: boolean;
+  isDisabled: boolean;
+};
+/**
+ * Encapsulates mutation lifecycle and side effects.
+ *
+ * Responsibilities:
+ * - Execute mutation with status transitions (`pending/success/error`)
+ * - Reset value on error to `initialValue`
+ * - Apply permission/disabled guards before mutating
+ * - Provide debounced and immediate mutation entry points
+ */
+type UseInlineMutationProps<TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> = {
+  variables?: (value: z$1.output<TSchema>) => TVariables;
+  mutation: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
+  state: ReturnType<typeof useInlineState<TValue>>;
+  access: ReturnType<typeof useInlineAccess>;
+};
+declare function useInlineMutation<TSchema extends z$1.ZodType, TValue, TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown>({
+  variables,
+  mutation,
+  state,
+  access
+}: UseInlineMutationProps<TSchema, TValue, TData, TError, TVariables, TOnMutateResult>): {
+  mutate: (input: z$1.output<TSchema>) => void;
+};
+/**
+ * Handles trigger-driven validation and mutation orchestration.
+ *
+ * Responsibilities:
+ * - Validate by trigger (`change/blur/commit`) using provided strategy
+ * - Encode input through parser before validation
+ * - Update local value immediately on trigger
+ * - Mutate only when trigger matches `strategy.mutate.on`
+ */
+type UseInlineStrategyProps<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue> = {
+  strategy: InlineStrategy<TSchema, TAllowedTrigger>;
+  parser: {
+    /**
+     * Transform the value from the result type to the value type
+     */
+    decode: (value: z$1.input<TSchema>) => TValue;
+    /**
+     * Transform the value from the value type to the result type
+     */
+    encode: (value: TValue) => z$1.input<TSchema>;
+  };
+  state: ReturnType<typeof useInlineState<TValue>>;
+  mutations: ReturnType<typeof useInlineMutation<TSchema, TValue>>;
+};
+declare function useInlineStrategy<TAllowedTrigger extends InlineTrigger, TSchema extends z$1.ZodType, TValue>({
+  strategy,
+  state,
+  mutations,
+  parser
+}: UseInlineStrategyProps<TAllowedTrigger, TSchema, TValue>): {
+  validate: <TValidator extends z$1.ZodType>(params: {
+    validator?: TValidator;
+    input: TValue | null;
+  }) => {
+    success: true;
+    data: z$1.output<TValidator>;
+  } | {
+    success: false;
+  };
+  handleTrigger: (trigger: TAllowedTrigger, input: TValue | null) => void;
+};
+//#endregion
+export { InlineStrategy, InlineTrigger, UseInlineAccessProps, UseInlineEditProps, UseInlineMutationProps, UseInlineStrategyProps, useInlineAccess, useInlineEditOptions, useInlineMutation, useInlineStrategy };

package/dist/src/modules/inline/hooks/use-inline.client.mjs

@@ -0,0 +1,125 @@
+"use client";
+
+import { usePermission } from "../../auth/hooks/use-permission.mjs";
+import { useAction } from "../../../lib/hooks/use-action.mjs";
+import { useInlineProviderContext } from "./inline-provider.mjs";
+import { useCallback } from "react";
+import { useDebouncedCallback } from "use-debounce";
+
+//#region src/modules/inline/hooks/use-inline.client.tsx
+function useInlineAccess({ permission, disabled }) {
+	const providerContext = useInlineProviderContext();
+	const isAllowed = usePermission({ permission: permission ?? providerContext.permission })?.success;
+	return {
+		isAllowed,
+		isDisabled: Boolean(providerContext.disabled || disabled || !isAllowed)
+	};
+}
+function useInlineMutation({ variables, mutation, state, access }) {
+	/**
+	* Wraps the mutation with status management and error handling.
+	* - Sets status to "pending" on mutate
+	* - On success, sets status to "success" and clears errors
+	* - On error, resets value to initial and sets status to "error"
+	*/
+	const action = useAction({
+		...mutation,
+		onMutate: async (...params) => {
+			state.setStatus("pending");
+			return await mutation.onMutate?.(...params);
+		},
+		onSuccess: async (...params) => {
+			state.setStatus("success");
+			state.setError(void 0);
+			return await mutation.onSuccess?.(...params);
+		},
+		onError: async (...params) => {
+			state.setValue(state.initialValue);
+			state.setStatus("error");
+			return await mutation.onError?.(...params);
+		}
+	});
+	return { mutate: useCallback((input) => {
+		if (!access.isAllowed) {
+			state.setStatus("error");
+			state.setError("Je hebt geen toestemming om dit te bewerken");
+			return;
+		}
+		if (access.isDisabled) return;
+		const nextVariables = variables ? variables(input) : input;
+		return action.mutate(nextVariables);
+	}, [
+		action,
+		access.isAllowed,
+		access.isDisabled,
+		state.setError,
+		state.setStatus,
+		variables
+	]) };
+}
+function useInlineStrategy({ strategy, state, mutations, parser }) {
+	/**
+	* Debounced mutation function that wraps `mutateInstant` with a debounce.
+	*/
+	const mutateDebounced = useDebouncedCallback(mutations.mutate, strategy.mutate.debounceMs ?? 0);
+	/**
+	* Main mutation function that checks if debounce is configured and calls the appropriate mutate function.
+	*/
+	const mutate = useCallback((input) => strategy.mutate.debounceMs ? mutateDebounced(input) : mutations.mutate(input), [
+		mutateDebounced,
+		mutations,
+		strategy.mutate.debounceMs
+	]);
+	/**
+	* Validate the input based on the trigger and strategy configuration.
+	*/
+	const validate = useCallback((params) => {
+		const encodedValue = params.input !== null ? parser.encode(params.input) : null;
+		if (!params.validator) {
+			state.setError(void 0);
+			state.setStatus((currentStatus) => currentStatus === "error" ? "idle" : currentStatus);
+			return {
+				success: true,
+				data: encodedValue
+			};
+		}
+		const result = params.validator.safeParse(encodedValue);
+		if (result.success) {
+			state.setError(void 0);
+			state.setStatus((currentStatus) => currentStatus === "error" ? "idle" : currentStatus);
+			return {
+				success: true,
+				data: result.data
+			};
+		}
+		const message = result.error.issues[0]?.message ?? "De ingevoerde waarde is ongeldig";
+		state.setStatus("error");
+		state.setError(message);
+		return { success: false };
+	}, [
+		parser,
+		state.setError,
+		state.setStatus
+	]);
+	return {
+		validate,
+		handleTrigger: useCallback((trigger, input) => {
+			state.setValue(input ?? void 0);
+			const validator = strategy.validate?.[trigger];
+			const result = validate({
+				validator,
+				input
+			});
+			if (!result.success || strategy.mutate.on !== trigger) return;
+			mutate(result.data);
+		}, [
+			mutate,
+			state.setValue,
+			strategy,
+			validate
+		])
+	};
+}
+
+//#endregion
+export { useInlineAccess, useInlineMutation, useInlineStrategy };

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

@@ -0,0 +1,56 @@
+import { ZodType, z as z$1 } from "zod";
+
+//#region src/modules/inline/lib/validators.d.ts
+/**
+ * Inline edit schema
+ */
+declare const inlineEditSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+}, z$1.core.$strip>;
+type InlineEditSchema<TValue> = z$1.infer<typeof inlineEditSchema> & {
+  value: TValue;
+};
+/**
+ * Create inline edit schema
+ */
+declare const createInlineEditSchema: <TValue extends ZodType>(value: TValue) => z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: TValue;
+}, z$1.core.$strip>;
+/**
+ * Inline edit string schema
+ */
+declare const inlineEditStringSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodString;
+}, z$1.core.$strip>;
+/**
+ * Inline edit number schema
+ */
+declare const inlineEditNumberSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodNumber;
+}, z$1.core.$strip>;
+/**
+ * Inline edit boolean schema
+ */
+declare const inlineEditBooleanSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodBoolean;
+}, z$1.core.$strip>;
+/**
+ * Inline edit date schema
+ */
+declare const inlineEditDateSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodDate;
+}, z$1.core.$strip>;
+/**
+ * Inline edit json schema
+ */
+declare const inlineEditJsonSchema: z$1.ZodObject<{
+  id: z$1.ZodString;
+  value: z$1.ZodAny;
+}, z$1.core.$strip>;
+//#endregion
+export { InlineEditSchema, createInlineEditSchema, inlineEditBooleanSchema, inlineEditDateSchema, inlineEditJsonSchema, inlineEditNumberSchema, inlineEditStringSchema };

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

@@ -0,0 +1,34 @@
+import { z as z$1 } from "zod";
+
+//#region src/modules/inline/lib/validators.ts
+/**
+* Inline edit schema
+*/
+const inlineEditSchema = z$1.object({ id: z$1.string() });
+/**
+* Create inline edit schema
+*/
+const createInlineEditSchema = (value) => inlineEditSchema.extend({ value });
+/**
+* Inline edit string schema
+*/
+const inlineEditStringSchema = createInlineEditSchema(z$1.string());
+/**
+* Inline edit number schema
+*/
+const inlineEditNumberSchema = createInlineEditSchema(z$1.number());
+/**
+* Inline edit boolean schema
+*/
+const inlineEditBooleanSchema = createInlineEditSchema(z$1.boolean());
+/**
+* Inline edit date schema
+*/
+const inlineEditDateSchema = createInlineEditSchema(z$1.date());
+/**
+* Inline edit json schema
+*/
+const inlineEditJsonSchema = createInlineEditSchema(z$1.any());
+
+//#endregion
+export { createInlineEditSchema, inlineEditBooleanSchema, inlineEditDateSchema, inlineEditJsonSchema, inlineEditNumberSchema, inlineEditStringSchema };

package/dist/src/modules/inline/lib/variants.d.mts

@@ -0,0 +1,11 @@
+import { VariantProps } from "class-variance-authority";
+import * as class_variance_authority_types0 from "class-variance-authority/types";
+
+//#region src/modules/inline/lib/variants.d.ts
+declare const inlineEditVariants: (props?: ({
+  variant?: "default" | "table" | null | undefined;
+  status?: "success" | "error" | "pending" | "idle" | null | undefined;
+} & class_variance_authority_types0.ClassProp) | undefined) => string;
+type InlineEditVariantsProps = VariantProps<typeof inlineEditVariants>;
+//#endregion
+export { InlineEditVariantsProps };

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 };