@vitnode/core 1.2.0-canary.10

package/dist/tsup.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("tsup").Options | import("tsup").Options[] | ((overrideOptions: import("tsup").Options) => import("tsup").Options | import("tsup").Options[] | Promise<import("tsup").Options | import("tsup").Options[]>);
+export default _default;
+//# sourceMappingURL=tsup.config.d.ts.map

package/dist/tsup.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBAgBG"}

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAKA,wBA8BG"}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@vitnode/core",
+  "version": "1.2.0-canary.10",
+  "devDependencies": {
+    "@hono/swagger-ui": "^0.5.1",
+    "@hono/zod-openapi": "^0.19.8",
+    "@hono/zod-validator": "^0.7.0",
+    "@hookform/resolvers": "^5.1.0",
+    "@react-email/components": "0.0.41",
+    "@swc/cli": "0.6.0",
+    "@swc/core": "^1.11.31",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^22.15.30",
+    "@types/nodemailer": "^6.4.17",
+    "@types/react": "^19.1.6",
+    "@types/react-dom": "^19.1.6",
+    "@vitejs/plugin-react": "^4.5.1",
+    "@vitest/coverage-v8": "^3.2.2",
+    "chokidar": "^4.0.3",
+    "concurrently": "^9.1.2",
+    "dotenv": "^16.5.0",
+    "drizzle-kit": "^0.31.1",
+    "drizzle-orm": "^0.44.2",
+    "eslint": "^9.28.0",
+    "hono": "^4.7.11",
+    "jsdom": "^26.1.0",
+    "lucide-react": "^0.513.0",
+    "next": "^15.3.3",
+    "next-intl": "^4.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-email": "^4.0.16",
+    "react-hook-form": "^7.57.0",
+    "sonner": "^2.0.5",
+    "tailwindcss": "^4.1.8",
+    "tsc-alias": "^1.8.16",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.4",
+    "tw-animate-css": "^1.3.4",
+    "typescript": "^5.8.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.2",
+    "zod": "^3.25.56",
+    "eslint-config-typescript-vitnode": "1.2.0-canary.10"
+  },
+  "bin": {
+    "vitnode": "./dist/scripts/scripts.js"
+  },
+  "exports": {
+    "./api/config": {
+      "import": "./dist/src/api/config.js",
+      "types": "./dist/src/api/config.d.ts",
+      "default": "./dist/src/api/config.js"
+    },
+    "./*": {
+      "import": "./dist/src/*.js",
+      "types": "./dist/src/*.d.ts",
+      "default": "./dist/src/*.js"
+    },
+    "./config/next.config": "./config/next.config.ts",
+    "./locales/en.json": "./src/locales/en.json"
+  },
+  "type": "module",
+  "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@tanstack/react-query": "^5.80.6",
+    "cache-manager": "^6.4.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "input-otp": "^1.4.2",
+    "next-themes": "^0.4.6",
+    "nodemailer": "^7.0.3",
+    "postgres": "^3.4.7",
+    "radix-ui": "^1.4.2",
+    "react-scan": "^0.3.4",
+    "resend": "^4.5.2",
+    "tailwind-merge": "^3.3.0",
+    "vaul": "^1.1.2"
+  },
+  "scripts": {
+    "build:scripts": "tsup",
+    "start:scripts": "node dist/scripts/scripts.js plugin --w",
+    "build:plugins": "tsc && swc src -d dist --config-file .swcrc && tsc-alias -p tsconfig.json",
+    "dev": "concurrently \"tsc -w --preserveWatchOutput\" \"swc src -d dist --config-file .swcrc -w\" \"tsc-alias -w\" \"node dist/scripts/scripts.js plugin --w\"",
+    "dev:email": "email dev",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}

package/src/app/login/page.tsx

@@ -0,0 +1,21 @@
+import type { Metadata } from 'next/dist/types';
+
+import { getTranslations } from 'next-intl/server';
+
+import { SignInView } from '../../views/auth/sign-in/sign-in-view';
+
+export const generateMetadata = async ({
+  locale,
+}: {
+  locale: string;
+}): Promise<Metadata> => {
+  const t = await getTranslations({ locale, namespace: 'core.global' });
+
+  return {
+    title: t('login'),
+  };
+};
+
+export default function Page() {
+  return <SignInView />;
+}

package/src/app/login/sso/[providerId]/page.tsx

@@ -0,0 +1,19 @@
+import { CallbackSSOView } from '@/views/auth/sso/callback/callback-sso-view';
+
+export default async function Page({
+  params,
+  searchParams,
+}: {
+  params: Promise<{ providerId: string }>;
+  searchParams: Promise<Record<string, string>>;
+}) {
+  const { providerId } = await params;
+  const currentSearchParams = await searchParams;
+
+  return (
+    <CallbackSSOView
+      providerId={providerId}
+      searchParams={currentSearchParams}
+    />
+  );
+}

package/src/app/register/page.tsx

@@ -0,0 +1,21 @@
+import type { Metadata } from 'next/dist/types';
+
+import { getTranslations } from 'next-intl/server';
+
+import { SignUpView } from '../../views/auth/sign-up/sign-up-view';
+
+export const generateMetadata = async ({
+  locale,
+}: {
+  locale: string;
+}): Promise<Metadata> => {
+  const t = await getTranslations({ locale, namespace: 'core.global' });
+
+  return {
+    title: t('register'),
+  };
+};
+
+export default function Page() {
+  return <SignUpView />;
+}

package/src/app_admin/core/page.tsx

@@ -0,0 +1,5 @@
+import { DashboardAdminView } from '../../views/admin/views/core/dashboard/dashboard-admin-view';
+
+export default function Page() {
+  return <DashboardAdminView />;
+}

package/src/app_admin/core/test/page.tsx

@@ -0,0 +1,5 @@
+import { TestView } from '../../../views/admin/views/core/test';
+
+export default function Page() {
+  return <TestView />;
+}

package/src/app_admin/core/users/page.tsx

@@ -0,0 +1,35 @@
+import type { Metadata } from 'next/dist/types';
+
+import { getTranslations } from 'next-intl/server';
+import React from 'react';
+
+import { DataTableSkeleton } from '@/components/table/data-table';
+import { HeaderContent } from '@/components/ui/header-content';
+import { UsersAdminView } from '@/views/admin/views/core/users/users-admin-view';
+
+export const generateMetadata = async (): Promise<Metadata> => {
+  const t = await getTranslations('admin.global.nav.users');
+
+  return {
+    title: t('list'),
+  };
+};
+
+export default async function Page(
+  props: React.ComponentProps<typeof UsersAdminView>,
+) {
+  const [t, tNav] = await Promise.all([
+    getTranslations('admin.user.list'),
+    getTranslations('admin.global.nav.users'),
+  ]);
+
+  return (
+    <div className="container mx-auto p-4">
+      <HeaderContent desc={t('desc')} h1={tNav('list')} />
+
+      <React.Suspense fallback={<DataTableSkeleton columns={2} />}>
+        <UsersAdminView {...props} />
+      </React.Suspense>
+    </div>
+  );
+}

package/src/database/admins.ts

@@ -0,0 +1,87 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable } from 'drizzle-orm/pg-core';
+
+import { core_roles } from './roles';
+import { core_sessions_known_devices } from './sessions';
+import { core_users } from './users';
+
+export const core_admin_permissions = pgTable(
+  'core_admin_permissions',
+  t => ({
+    id: t.serial().primaryKey(),
+    roleId: t.integer().references(() => core_roles.id, {
+      onDelete: 'cascade',
+    }),
+    userId: t.integer().references(() => core_users.id, {
+      onDelete: 'cascade',
+    }),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    updatedAt: t
+      .timestamp()
+      .notNull()
+      .$onUpdate(() => new Date()),
+    protected: t.boolean().notNull().default(false),
+    // data: t.jsonb().$type<{ permissions: PermissionsStaffArgs[] }>().default({
+    //   permissions: [],
+    // }),
+  }),
+  t => [
+    index('core_admin_permissions_role_id_idx').on(t.roleId),
+    index('core_admin_permissions_user_id_idx').on(t.userId),
+  ],
+).enableRLS();
+
+export const core_admin_permissions_relations = relations(
+  core_admin_permissions,
+  ({ one }) => ({
+    group: one(core_roles, {
+      fields: [core_admin_permissions.roleId],
+      references: [core_roles.id],
+    }),
+    user: one(core_users, {
+      fields: [core_admin_permissions.userId],
+      references: [core_users.id],
+    }),
+  }),
+);
+
+export const core_admin_sessions = pgTable(
+  'core_admin_sessions',
+  t => ({
+    id: t.serial().primaryKey(),
+    token: t.varchar({ length: 255 }).notNull().unique(),
+    userId: t
+      .integer()
+      .notNull()
+      .references(() => core_users.id, {
+        onDelete: 'cascade',
+      }),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    lastSeen: t.timestamp().notNull().defaultNow(),
+    expiresAt: t.timestamp().notNull(),
+    deviceId: t
+      .integer()
+      .references(() => core_sessions_known_devices.id, {
+        onDelete: 'cascade',
+      })
+      .notNull(),
+  }),
+  t => [
+    index('core_admin_sessions_token_idx').on(t.token),
+    index('core_admin_sessions_user_id_idx').on(t.userId),
+  ],
+).enableRLS();
+
+export const core_admin_sessions_relations = relations(
+  core_admin_sessions,
+  ({ one }) => ({
+    user: one(core_users, {
+      fields: [core_admin_sessions.userId],
+      references: [core_users.id],
+    }),
+    device: one(core_sessions_known_devices, {
+      fields: [core_admin_sessions.deviceId],
+      references: [core_sessions_known_devices.id],
+    }),
+  }),
+);

package/src/database/languages.ts

@@ -0,0 +1,54 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable } from 'drizzle-orm/pg-core';
+
+export const core_languages = pgTable(
+  'core_languages',
+  t => ({
+    id: t.serial().primaryKey(),
+    code: t.varchar({ length: 32 }).notNull().unique(),
+    name: t.varchar({ length: 255 }).notNull(),
+    timezone: t.varchar({ length: 255 }).notNull().default('UTC'),
+    protected: t.boolean().notNull().default(false),
+    default: t.boolean().notNull().default(false),
+    enabled: t.boolean().notNull().default(true),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    updatedAt: t
+      .timestamp()
+      .notNull()
+      .$onUpdate(() => new Date()),
+    time24: t.boolean().notNull().default(false),
+  }),
+  t => [
+    index('core_languages_code_idx').on(t.code),
+    index('core_languages_name_idx').on(t.name),
+  ],
+).enableRLS();
+
+export const core_languages_words = pgTable(
+  'core_languages_words',
+  t => ({
+    id: t.serial().primaryKey(),
+    languageCode: t
+      .varchar()
+      .notNull()
+      .references(() => core_languages.code, {
+        onDelete: 'cascade',
+      }),
+    pluginCode: t.varchar({ length: 50 }).notNull(),
+    itemId: t.integer().notNull(),
+    value: t.text().notNull(),
+    tableName: t.varchar({ length: 255 }).notNull(),
+    variable: t.varchar({ length: 255 }).notNull(),
+  }),
+  t => [index('core_languages_words_lang_code_idx').on(t.languageCode)],
+).enableRLS();
+
+export const core_languages_words_relations = relations(
+  core_languages_words,
+  ({ one }) => ({
+    language: one(core_languages, {
+      fields: [core_languages_words.languageCode],
+      references: [core_languages.code],
+    }),
+  }),
+);

package/src/database/moderators.ts

@@ -0,0 +1,42 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable } from 'drizzle-orm/pg-core';
+
+import { core_roles } from './roles';
+import { core_users } from './users';
+
+export const core_moderators_permissions = pgTable(
+  'core_moderators_permissions',
+  t => ({
+    id: t.serial().primaryKey(),
+    roleId: t.integer().references(() => core_roles.id, {
+      onDelete: 'cascade',
+    }),
+    userId: t.integer().references(() => core_users.id, {
+      onDelete: 'cascade',
+    }),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    updatedAt: t
+      .timestamp()
+      .notNull()
+      .$onUpdate(() => new Date()),
+    protected: t.boolean().notNull().default(false),
+  }),
+  t => [
+    index('core_moderators_permissions_role_id_idx').on(t.roleId),
+    index('core_moderators_permissions_user_id_idx').on(t.userId),
+  ],
+).enableRLS();
+
+export const core_moderators_permissions_relations = relations(
+  core_moderators_permissions,
+  ({ one }) => ({
+    group: one(core_roles, {
+      fields: [core_moderators_permissions.roleId],
+      references: [core_roles.id],
+    }),
+    user: one(core_users, {
+      fields: [core_moderators_permissions.userId],
+      references: [core_users.id],
+    }),
+  }),
+);

package/src/database/roles.ts

@@ -0,0 +1,15 @@
+import { pgTable } from 'drizzle-orm/pg-core';
+
+export const core_roles = pgTable('core_roles', t => ({
+  id: t.serial().primaryKey(),
+  createdAt: t.timestamp().notNull().defaultNow(),
+  updatedAt: t
+    .timestamp()
+    .notNull()
+    .$onUpdate(() => new Date()),
+  protected: t.boolean().notNull().default(false),
+  default: t.boolean().notNull().default(false),
+  root: t.boolean().notNull().default(false),
+  guest: t.boolean().notNull().default(false),
+  color: t.varchar({ length: 19 }),
+})).enableRLS();

package/src/database/sessions.ts

@@ -0,0 +1,59 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable } from 'drizzle-orm/pg-core';
+
+import { core_users } from './users';
+
+export const core_sessions = pgTable(
+  'core_sessions',
+  t => ({
+    id: t.serial().primaryKey(),
+    token: t.varchar({ length: 255 }).notNull().unique(),
+    userId: t
+      .integer()
+      .notNull()
+      .references(() => core_users.id, {
+        onDelete: 'cascade',
+      }),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    expiresAt: t.timestamp().notNull(),
+    deviceId: t
+      .integer()
+      .references(() => core_sessions_known_devices.id, {
+        onDelete: 'cascade',
+      })
+      .notNull(),
+  }),
+  t => [index('core_sessions_user_id_idx').on(t.userId)],
+).enableRLS();
+
+export const core_sessions_relations = relations(core_sessions, ({ one }) => ({
+  user: one(core_users, {
+    fields: [core_sessions.userId],
+    references: [core_users.id],
+  }),
+  device: one(core_sessions_known_devices, {
+    fields: [core_sessions.deviceId],
+    references: [core_sessions_known_devices.id],
+  }),
+}));
+
+export const core_sessions_known_devices = pgTable(
+  'core_sessions_known_devices',
+  t => ({
+    id: t.serial().primaryKey(),
+    ipAddress: t.varchar({ length: 40 }).notNull(),
+    userAgent: t.text().notNull(),
+    lastSeen: t.timestamp().notNull().defaultNow(),
+  }),
+  t => [index('core_sessions_known_devices_ip_address_idx').on(t.ipAddress)],
+).enableRLS();
+
+export const core_sessions_known_devices_relations = relations(
+  core_sessions_known_devices,
+  ({ one }) => ({
+    session: one(core_sessions, {
+      fields: [core_sessions_known_devices.id],
+      references: [core_sessions.deviceId],
+    }),
+  }),
+);

package/src/database/users.ts

@@ -0,0 +1,142 @@
+import { relations } from 'drizzle-orm';
+import { index, pgTable } from 'drizzle-orm/pg-core';
+
+import { core_languages } from './languages';
+import { core_roles } from './roles';
+
+export const core_users = pgTable(
+  'core_users',
+  t => ({
+    id: t.serial().primaryKey(),
+    nameCode: t.varchar({ length: 255 }).notNull().unique(),
+    name: t.varchar({ length: 255 }).notNull().unique(),
+    email: t.varchar({ length: 255 }).notNull().unique(),
+    password: t.varchar(),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    newsletter: t.boolean().notNull().default(false),
+    avatarColor: t.varchar({ length: 6 }).notNull(),
+    emailVerified: t.boolean().notNull().default(false),
+    roleId: t
+      .integer()
+      .references(() => core_roles.id)
+      .notNull(),
+    birthday: t.timestamp(),
+    ipAddress: t.varchar({ length: 40 }).notNull(),
+    language: t
+      .varchar({ length: 32 })
+      .notNull()
+      .default('en')
+      .references(() => core_languages.code, {
+        onDelete: 'set default',
+      }),
+  }),
+  t => [
+    index('core_users_name_code_idx').on(t.nameCode),
+    index('core_users_name_idx').on(t.name),
+    index('core_users_email_idx').on(t.email),
+  ],
+).enableRLS();
+
+export const core_users_relations = relations(core_users, ({ one, many }) => ({
+  group: one(core_roles, {
+    fields: [core_users.roleId],
+    references: [core_roles.id],
+  }),
+  language: one(core_languages, {
+    fields: [core_users.language],
+    references: [core_languages.code],
+  }),
+  confirm_email: one(core_users_confirm_emails, {
+    fields: [core_users.id],
+    references: [core_users_confirm_emails.userId],
+  }),
+  sso: many(core_users_sso),
+  forgot_password: one(core_users_forgot_password, {
+    fields: [core_users.id],
+    references: [core_users_forgot_password.userId],
+  }),
+}));
+
+export const core_users_sso = pgTable(
+  'core_users_sso',
+  t => ({
+    userId: t
+      .integer()
+      .references(() => core_users.id, {
+        onDelete: 'cascade',
+      })
+      .notNull(),
+    providerId: t.varchar({ length: 255 }).notNull(),
+    providerAccountId: t.varchar({ length: 255 }).notNull(),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    updatedAt: t
+      .timestamp()
+      .notNull()
+      .$onUpdate(() => new Date()),
+  }),
+  t => [index('core_users_sso_user_id_idx').on(t.userId)],
+).enableRLS();
+
+export const core_users_sso_relations = relations(
+  core_users_sso,
+  ({ one }) => ({
+    user: one(core_users, {
+      fields: [core_users_sso.userId],
+      references: [core_users.id],
+    }),
+  }),
+);
+
+export const core_users_confirm_emails = pgTable(
+  'core_users_confirm_emails',
+  t => ({
+    id: t.serial().primaryKey(),
+    userId: t
+      .integer()
+      .references(() => core_users.id, {
+        onDelete: 'cascade',
+      })
+      .notNull(),
+    token: t.varchar({ length: 100 }).notNull().unique(),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    expires: t.timestamp().notNull(),
+  }),
+).enableRLS();
+
+export const core_users_confirm_emails_relations = relations(
+  core_users_confirm_emails,
+  ({ one }) => ({
+    user: one(core_users, {
+      fields: [core_users_confirm_emails.userId],
+      references: [core_users.id],
+    }),
+  }),
+);
+
+export const core_users_forgot_password = pgTable(
+  'core_users_forgot_password',
+  t => ({
+    id: t.serial().primaryKey(),
+    userId: t
+      .integer()
+      .references(() => core_users.id, {
+        onDelete: 'cascade',
+      })
+      .notNull()
+      .unique(),
+    token: t.varchar({ length: 100 }).notNull().unique(),
+    ip_address: t.varchar({ length: 40 }).notNull(),
+    createdAt: t.timestamp().notNull().defaultNow(),
+    expiresAt: t.timestamp().notNull(),
+  }),
+).enableRLS();
+
+export const core_users_forgot_password_relations = relations(
+  core_users_forgot_password,
+  ({ one }) => ({
+    user: one(core_users, {
+      fields: [core_users_forgot_password.userId],
+      references: [core_users.id],
+    }),
+  }),
+);