@vitnode/core 1.2.0-canary.10

package/dist/src/database/languages.d.ts

@@ -0,0 +1,321 @@
+export declare const core_languages: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_languages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_languages";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "core_languages";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 32;
+        }>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "core_languages";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        timezone: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timezone";
+            tableName: "core_languages";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        protected: import("drizzle-orm/pg-core").PgColumn<{
+            name: "protected";
+            tableName: "core_languages";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        default: import("drizzle-orm/pg-core").PgColumn<{
+            name: "default";
+            tableName: "core_languages";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "core_languages";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "core_languages";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "core_languages";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        time24: import("drizzle-orm/pg-core").PgColumn<{
+            name: "time24";
+            tableName: "core_languages";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export declare const core_languages_words: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_languages_words";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_languages_words";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        languageCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "languageCode";
+            tableName: "core_languages_words";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        pluginCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "pluginCode";
+            tableName: "core_languages_words";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 50;
+        }>;
+        itemId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "itemId";
+            tableName: "core_languages_words";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "core_languages_words";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tableName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tableName";
+            tableName: "core_languages_words";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        variable: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variable";
+            tableName: "core_languages_words";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export declare const core_languages_words_relations: import("drizzle-orm").Relations<"core_languages_words", {
+    language: import("drizzle-orm").One<"core_languages", true>;
+}>;
+//# sourceMappingURL=languages.d.ts.map

package/dist/src/database/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../../src/database/languages.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAqBd,CAAC;AAEd,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAiBpB,CAAC;AAEd,eAAO,MAAM,8BAA8B;;EAQ1C,CAAC"}

package/dist/src/database/languages.js

@@ -0,0 +1,52 @@
+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/dist/src/database/moderators.d.ts

@@ -0,0 +1,114 @@
+export declare const core_moderators_permissions: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_moderators_permissions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_moderators_permissions";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        roleId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "roleId";
+            tableName: "core_moderators_permissions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "userId";
+            tableName: "core_moderators_permissions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "core_moderators_permissions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "core_moderators_permissions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        protected: import("drizzle-orm/pg-core").PgColumn<{
+            name: "protected";
+            tableName: "core_moderators_permissions";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export declare const core_moderators_permissions_relations: import("drizzle-orm").Relations<"core_moderators_permissions", {
+    group: import("drizzle-orm").One<"core_roles", false>;
+    user: import("drizzle-orm").One<"core_users", false>;
+}>;
+//# sourceMappingURL=moderators.d.ts.map

package/dist/src/database/moderators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moderators.d.ts","sourceRoot":"","sources":["../../../src/database/moderators.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAqB3B,CAAC;AAEd,eAAO,MAAM,qCAAqC;;;EAYjD,CAAC"}

package/dist/src/database/moderators.js

@@ -0,0 +1,37 @@
+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/dist/src/database/roles.d.ts

@@ -0,0 +1,146 @@
+export declare const core_roles: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "core_roles";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "core_roles";
+            dataType: "number";
+            columnType: "PgSerial";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "core_roles";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updatedAt";
+            tableName: "core_roles";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        protected: import("drizzle-orm/pg-core").PgColumn<{
+            name: "protected";
+            tableName: "core_roles";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        default: import("drizzle-orm/pg-core").PgColumn<{
+            name: "default";
+            tableName: "core_roles";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        root: import("drizzle-orm/pg-core").PgColumn<{
+            name: "root";
+            tableName: "core_roles";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        guest: import("drizzle-orm/pg-core").PgColumn<{
+            name: "guest";
+            tableName: "core_roles";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        color: import("drizzle-orm/pg-core").PgColumn<{
+            name: "color";
+            tableName: "core_roles";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 19;
+        }>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+//# sourceMappingURL=roles.d.ts.map

package/dist/src/database/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../../src/database/roles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAYR,CAAC"}

package/dist/src/database/roles.js

@@ -0,0 +1,13 @@
+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();