@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/providers/better-t-stack/packed/api.js

@@ -0,0 +1,678 @@
+export const DLER_TPL_API = {
+  name: "api",
+  description: "Template generated from 13 files",
+  updatedAt: "2025-06-17T20:33:59.544Z",
+  config: {
+    files: {
+      "api/orpc/native/utils/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "911ac0411a"
+        },
+        content: `import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+import type { RouterClient } from "@orpc/server";
+import { QueryCache, QueryClient } from "@tanstack/react-query";
+import type { appRouter } from "../../server/src/routers";
+{{#if auth}}
+import { authClient } from "@/lib/auth-client";
+{{/if}}
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      console.log(error)
+    },
+  }),
+});
+export const link = new RPCLink({
+  url: \`\${process.env.EXPO_PUBLIC_SERVER_URL}/rpc\`,
+  {{#if auth}}
+  headers() {
+    const headers = new Map<string, string>();
+    const cookies = authClient.getCookie();
+    if (cookies) {
+      headers.set("Cookie", cookies);
+    }
+    return Object.fromEntries(headers);
+  },
+  {{/if}}
+});
+export const client: RouterClient<typeof appRouter> = createORPCClient(link);
+export const orpc = createTanstackQueryUtils(client);
+`,
+        type: "text"
+      },
+      "api/orpc/server/base/src/lib/context.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "83bd3d8a84"
+        },
+        content: `{{#if (eq backend 'next')}}
+import type { NextRequest } from "next/server";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext(req: NextRequest) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: req.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  return {}
+{{/if}}
+}
+{{else if (eq backend 'hono')}}
+import type { Context as HonoContext } from "hono";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export type CreateContextOptions = {
+  context: HonoContext;
+};
+export async function createContext({ context }: CreateContextOptions) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: context.req.raw.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else if (eq backend 'elysia')}}
+import type { Context as ElysiaContext } from "elysia";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export type CreateContextOptions = {
+  context: ElysiaContext;
+};
+export async function createContext({ context }: CreateContextOptions) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: context.request.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else if (eq backend 'express')}}
+{{#if auth}}
+import { fromNodeHeaders } from "better-auth/node";
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext(opts: any) {
+{{#if auth}}
+	const session = await auth.api.getSession({
+		headers: fromNodeHeaders(opts.req.headers),
+	});
+	return {
+		session,
+	};
+{{else}}
+  // No auth configured
+	return {
+		session: null,
+	};
+{{/if}}
+}
+{{else if (eq backend 'fastify')}}
+import type { IncomingHttpHeaders } from "node:http";
+{{#if auth}}
+import { fromNodeHeaders } from "better-auth/node";
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext(req: IncomingHttpHeaders) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: fromNodeHeaders(req),
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else}}
+export async function createContext() {
+  return {
+    session: null,
+  };
+}
+{{/if}}
+export type Context = Awaited<ReturnType<typeof createContext>>;
+`,
+        type: "text"
+      },
+      "api/orpc/server/base/src/lib/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "3749886982"
+        },
+        content: `import { ORPCError, os } from "@orpc/server";
+import type { Context } from "./context";
+export const o = os.$context<Context>();
+export const publicProcedure = o;
+{{#if auth}}
+const requireAuth = o.middleware(async ({ context, next }) => {
+  if (!context.session?.user) {
+    throw new ORPCError("UNAUTHORIZED");
+  }
+  return next({
+    context: {
+      session: context.session,
+    },
+  });
+});
+export const protectedProcedure = publicProcedure.use(requireAuth);
+{{/if}}
+`,
+        type: "text"
+      },
+      "api/orpc/server/next/src/app/rpc/[...all]/route.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "cdf4279672"
+        },
+        content: `{{#if auth}}
+import { createContext } from '@/lib/context'
+{{/if}}
+import { appRouter } from '@/routers'
+import { RPCHandler } from '@orpc/server/fetch'
+import { NextRequest } from 'next/server'
+const handler = new RPCHandler(appRouter)
+async function handleRequest(req: NextRequest) {
+  const { response } = await handler.handle(req, {
+    prefix: '/rpc',
+    context: {{#if auth}}await createContext(req){{else}}{}{{/if}},
+  })
+  return response ?? new Response('Not found', { status: 404 })
+}
+export const GET = handleRequest
+export const POST = handleRequest
+export const PUT = handleRequest
+export const PATCH = handleRequest
+export const DELETE = handleRequest
+`,
+        type: "text"
+      },
+      "api/orpc/web/nuxt/app/plugins/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "77efd9809c"
+        },
+        content: `import { defineNuxtPlugin, useRuntimeConfig } from '#app'
+import type { RouterClient } from '@orpc/server'
+import type { appRouter } from "../../../server/src/routers/index";
+import { createORPCClient } from '@orpc/client'
+import { RPCLink } from '@orpc/client/fetch'
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+export default defineNuxtPlugin(() => {
+  const config = useRuntimeConfig()
+  const serverUrl = config.public.serverURL
+  const rpcUrl = \`\${serverUrl}/rpc\`;
+  const rpcLink = new RPCLink({
+    url: rpcUrl,
+    {{#if auth}}
+    fetch(url, options) {
+        return fetch(url, {
+        ...options,
+        credentials: "include",
+        });
+    },
+    {{/if}}
+  })
+  const client: RouterClient<typeof appRouter> = createORPCClient(rpcLink)
+  const orpcUtils = createTanstackQueryUtils(client)
+  return {
+    provide: {
+      orpc: orpcUtils
+    }
+  }
+})
+`,
+        type: "text"
+      },
+      "api/orpc/web/react/base/src/utils/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "9ab6c8a4c0"
+        },
+        content: `import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+import { QueryCache, QueryClient } from "@tanstack/react-query";
+import { toast } from "sonner";
+import type { appRouter } from "../../../server/src/routers/index";
+import type { RouterClient } from "@orpc/server";
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      toast.error(\`Error: \${error.message}\`, {
+        action: {
+          label: "retry",
+          onClick: () => {
+            queryClient.invalidateQueries();
+          },
+        },
+      });
+    },
+  }),
+});
+export const link = new RPCLink({
+  {{#if (includes frontend "next")}}
+  url: \`\${process.env.NEXT_PUBLIC_SERVER_URL}/rpc\`,
+  {{else}}
+  url: \`\${import.meta.env.VITE_SERVER_URL}/rpc\`,
+  {{/if}}
+  {{#if auth}}
+  fetch(url, options) {
+    return fetch(url, {
+      ...options,
+      credentials: "include",
+    });
+  },
+  {{/if}}
+});
+export const client: RouterClient<typeof appRouter> = createORPCClient(link)
+export const orpc = createTanstackQueryUtils(client)
+`,
+        type: "text"
+      },
+      "api/orpc/web/solid/src/utils/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "6d53d8cc60"
+        },
+        content: `import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+import { QueryCache, QueryClient } from "@tanstack/solid-query";
+import type { appRouter } from "../../../server/src/routers/index";
+import type { RouterClient } from "@orpc/server";
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      console.error(\`Error: \${error.message}\`);
+    },
+  }),
+});
+export const link = new RPCLink({
+  url: \`\${import.meta.env.VITE_SERVER_URL}/rpc\`,
+  {{#if auth}}
+  fetch(url, options) {
+    return fetch(url, {
+      ...options,
+      credentials: "include",
+    });
+  },
+  {{/if}}
+});
+export const client: RouterClient<typeof appRouter> = createORPCClient(link);
+export const orpc = createTanstackQueryUtils(client);
+`,
+        type: "text"
+      },
+      "api/orpc/web/svelte/src/lib/orpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "b8abb27944"
+        },
+        content: `import { PUBLIC_SERVER_URL } from "$env/static/public";
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import type { RouterClient } from "@orpc/server";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+import { QueryCache, QueryClient } from "@tanstack/svelte-query";
+import type { appRouter } from "../../../server/src/routers/index";
+export const queryClient = new QueryClient({
+	queryCache: new QueryCache({
+		onError: (error) => {
+			console.error(\`Error: \${error.message}\`);
+		},
+	}),
+});
+export const link = new RPCLink({
+	url: \`\${PUBLIC_SERVER_URL}/rpc\`,
+	{{#if auth}}
+	fetch(url, options) {
+		return fetch(url, {
+			...options,
+			credentials: "include",
+		});
+	},
+	{{/if}}
+});
+export const client: RouterClient<typeof appRouter> = createORPCClient(link);
+export const orpc = createTanstackQueryUtils(client);
+`,
+        type: "text"
+      },
+      "api/trpc/native/utils/trpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "ef6c8402a6"
+        },
+        content: `{{#if auth}}
+import { authClient } from "@/lib/auth-client";
+{{/if}}
+import { QueryClient } from "@tanstack/react-query";
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import { createTRPCOptionsProxy } from "@trpc/tanstack-react-query";
+import type { AppRouter } from "../../server/src/routers";
+export const queryClient = new QueryClient();
+const trpcClient = createTRPCClient<AppRouter>({
+	links: [
+		httpBatchLink({
+			url: \`\${process.env.EXPO_PUBLIC_SERVER_URL}/trpc\`,
+			{{#if auth}}
+			headers() {
+				const headers = new Map<string, string>();
+				const cookies = authClient.getCookie();
+				if (cookies) {
+					headers.set("Cookie", cookies);
+				}
+				return Object.fromEntries(headers);
+			},
+			{{/if}}
+		}),
+	],
+});
+export const trpc = createTRPCOptionsProxy<AppRouter>({
+	client: trpcClient,
+	queryClient,
+});
+`,
+        type: "text"
+      },
+      "api/trpc/server/base/src/lib/context.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "5c7ccd24ba"
+        },
+        content: `{{#if (eq backend 'next')}}
+import type { NextRequest } from "next/server";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext(req: NextRequest) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: req.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else if (eq backend 'hono')}}
+import type { Context as HonoContext } from "hono";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export type CreateContextOptions = {
+  context: HonoContext;
+};
+export async function createContext({ context }: CreateContextOptions) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: context.req.raw.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else if (eq backend 'elysia')}}
+import type { Context as ElysiaContext } from "elysia";
+{{#if auth}}
+import { auth } from "./auth.js";
+{{/if}}
+export type CreateContextOptions = {
+  context: ElysiaContext;
+};
+export async function createContext({ context }: CreateContextOptions) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: context.request.headers,
+  });
+  return {
+    session,
+  };
+{{else}}
+  // No auth configured
+  return {
+    session: null,
+  };
+{{/if}}
+}
+{{else if (eq backend 'express')}}
+import type { CreateExpressContextOptions } from "@trpc/server/adapters/express";
+{{#if auth}}
+import { fromNodeHeaders } from "better-auth/node";
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext(opts: CreateExpressContextOptions) {
+{{#if auth}}
+	const session = await auth.api.getSession({
+		headers: fromNodeHeaders(opts.req.headers),
+	});
+	return {
+		session,
+	};
+{{else}}
+  // No auth configured
+	return {
+		session: null,
+	};
+{{/if}}
+}
+{{else if (eq backend 'fastify')}}
+import type { CreateFastifyContextOptions } from "@trpc/server/adapters/fastify";
+{{#if auth}}
+import { fromNodeHeaders } from "better-auth/node";
+import { auth } from "./auth.js";
+{{/if}}
+export async function createContext({ req, res }: CreateFastifyContextOptions) {
+{{#if auth}}
+  const session = await auth.api.getSession({
+    headers: fromNodeHeaders(req.headers),
+  });
+  return { session };
+{{else}}
+  // No auth configured
+	return {
+		session: null,
+	};
+{{/if}}
+}
+{{else}}
+export async function createContext() {
+  return {
+    session: null,
+  };
+}
+{{/if}}
+export type Context = Awaited<ReturnType<typeof createContext>>;
+`,
+        type: "text"
+      },
+      "api/trpc/server/base/src/lib/trpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "f112e6ba22"
+        },
+        content: `import { initTRPC, TRPCError } from "@trpc/server";
+import type { Context } from "./context";
+export const t = initTRPC.context<Context>().create();
+export const router = t.router;
+export const publicProcedure = t.procedure;
+{{#if auth}}
+export const protectedProcedure = t.procedure.use(({ ctx, next }) => {
+  if (!ctx.session) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Authentication required",
+      cause: "No session",
+    });
+  }
+  return next({
+    ctx: {
+      ...ctx,
+      session: ctx.session,
+    },
+  });
+});
+{{/if}}
+`,
+        type: "text"
+      },
+      "api/trpc/server/next/src/app/trpc/[trpc]/route.ts": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "1316017eae"
+        },
+        content: `import { fetchRequestHandler } from '@trpc/server/adapters/fetch';
+import { appRouter } from '@/routers';
+import { createContext } from '@/lib/context';
+import { NextRequest } from 'next/server';
+function handler(req: NextRequest) {
+  return fetchRequestHandler({
+    endpoint: '/trpc',
+    req,
+    router: appRouter,
+    createContext: () => createContext(req)
+  });
+}
+export { handler as GET, handler as POST };
+`,
+        type: "text"
+      },
+      "api/trpc/web/react/base/src/utils/trpc.ts.hbs": {
+        metadata: {
+          updatedAt: "2025-06-17T06:06:35.000Z",
+          updatedHash: "724dc936a4"
+        },
+        content: `{{#if (includes frontend 'next')}}
+import { QueryCache, QueryClient } from '@tanstack/react-query';
+import { createTRPCClient, httpBatchLink } from '@trpc/client';
+import { createTRPCOptionsProxy } from '@trpc/tanstack-react-query';
+import type { AppRouter } from '../../../server/src/routers';
+import { toast } from 'sonner';
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      toast.error(error.message, {
+        action: {
+          label: "retry",
+          onClick: () => {
+            queryClient.invalidateQueries();
+          },
+        },
+      });
+    },
+  }),
+});
+const trpcClient = createTRPCClient<AppRouter>({
+  links: [
+    httpBatchLink({
+      {{#if (includes frontend 'next')}}
+      url: \`\${process.env.NEXT_PUBLIC_SERVER_URL}/trpc\`,
+      {{else}}
+      url: \`\${import.meta.env.VITE_SERVER_URL}/trpc\`,
+      {{/if}}
+      {{#if auth}}
+      fetch(url, options) {
+        return fetch(url, {
+          ...options,
+          credentials: "include",
+        });
+      },
+      {{/if}}
+    }),
+  ],
+})
+export const trpc = createTRPCOptionsProxy<AppRouter>({
+  client: trpcClient,
+  queryClient,
+});
+{{else if (includes frontend 'tanstack-start')}}
+import { createTRPCContext } from "@trpc/tanstack-react-query";
+import type { AppRouter } from "../../../server/src/routers";
+export const { TRPCProvider, useTRPC, useTRPCClient } =
+  createTRPCContext<AppRouter>();
+{{else}}
+import type { AppRouter } from "../../../server/src/routers";
+import { QueryCache, QueryClient } from "@tanstack/react-query";
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import { createTRPCOptionsProxy } from "@trpc/tanstack-react-query";
+import { toast } from "sonner";
+export const queryClient = new QueryClient({
+  queryCache: new QueryCache({
+    onError: (error) => {
+      toast.error(error.message, {
+        action: {
+          label: "retry",
+          onClick: () => {
+            queryClient.invalidateQueries();
+          },
+        },
+      });
+    },
+  }),
+});
+export const trpcClient = createTRPCClient<AppRouter>({
+  links: [
+    httpBatchLink({
+      url: \`\${import.meta.env.VITE_SERVER_URL}/trpc\`,
+      {{#if auth}}
+      fetch(url, options) {
+        return fetch(url, {
+          ...options,
+          credentials: "include",
+        });
+      },
+      {{/if}}
+    }),
+  ],
+});
+export const trpc = createTRPCOptionsProxy<AppRouter>({
+  client: trpcClient,
+  queryClient,
+});
+{{/if}}
+`,
+        type: "text"
+      }
+    }
+  }
+};

package/bin/app/providers/better-t-stack/packed/auth.d.ts

@@ -0,0 +1,2 @@
+import type { Template } from "../better-t-stack-types.ts";
+export declare const DLER_TPL_AUTH: Template;