@vitnode/core 1.2.0-canary.15 → 1.2.0-canary.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitnode/core",
-  "version": "1.2.0-canary.15",
+  "version": "1.2.0-canary.17",
   "description": "Core package for VitNode, providing essential functionalities and configurations.",
   "author": "VitNode Team",
   "license": "MIT",
@@ -59,7 +59,7 @@
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.2",
     "zod": "^3.25.56",
-    "@vitnode/eslint-config": "1.2.0-canary.15"
+    "@vitnode/eslint-config": "1.2.0-canary.17"
   },
   "bin": {
     "vitnode": "./dist/scripts/scripts.js"

package/src/drizzle.config.ts

@@ -20,6 +20,7 @@ export const defineVitNodeDrizzleConfig = ({
         process.cwd(),
         'node_modules',
         itemId,
+        'dist',
         'src',
         'database',
       );
@@ -32,16 +33,11 @@ export const defineVitNodeDrizzleConfig = ({
       // Check if there are any .ts files in the directory
       try {
         const files = readdirSync(pluginPath);
-        const hasSchemaFiles = files.some(
-          file => file.endsWith('.ts') && !file.endsWith('.d.ts'),
-        );
-
-        if (!hasSchemaFiles) {
-          return null;
-        }
+        const hasSchemaFiles = files.some(file => file.endsWith('.js'));
+        if (!hasSchemaFiles) return null;
 
         // Return glob pattern for schema files
-        return join(pluginPath, '*.ts').replace(/\\/g, '/');
+        return join(pluginPath, '*.js').replace(/\\/g, '/');
       } catch {
         return null;
       }

package/src/database/admins.ts

@@ -1,87 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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],
-    }),
-  }),
-);