switched db to lowdb

drizzle.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "drizzle-kit";
-
-export default defineConfig({
-  out: "./drizzle",
-  schema: "./src/lib/server/db/schema",
-  dialect: "sqlite",
-  dbCredentials: {
-    url: "./data/db.sqlite",
-  },
-});

package.json

@@ -18,7 +18,6 @@
 		"@sveltejs/kit": "^2.16.0",
 		"@sveltejs/vite-plugin-svelte": "^5.0.0",
 		"@tailwindcss/vite": "^4.0.0",
-		"drizzle-kit": "^0.30.6",
 		"prettier": "^3.4.2",
 		"prettier-plugin-svelte": "^3.3.3",
 		"svelte": "^5.0.0",
@@ -29,9 +28,9 @@
 		"vite": "^6.2.5"
 	},
 	"dependencies": {
-		"@libsql/client": "^0.15.2",
 		"bcryptjs": "^3.0.2",
 		"drizzle-orm": "^0.41.0",
+		"lowdb": "^7.0.1",
 		"nanoid": "^5.1.5"
 	},
 	"overrides": {

src/hooks.server.ts

@@ -1,25 +1,29 @@
 import { db } from "$lib/server/db/db";
-import { users } from "$lib/server/db/schema/_index";
 import type { ServerInit } from "@sveltejs/kit";
 import bcrypt from "bcryptjs";
 import { nanoid } from "nanoid";
 import { writeFileSync } from "fs";
 
 export const init: ServerInit = async () => {
-    const anyUser = await db.query.users.findFirst();
+    const anyUser = db.data.users.at(0);
 
     if (!anyUser) {
         const pass = nanoid(12);
 
-        await db.insert(users).values({
-            name: "admin",
-            admin: true,
-            password: bcrypt.hashSync(pass),
+        await db.update(({ users }) => {
+            users.push({
+                id: nanoid(),
+                name: "admin",
+                password: bcrypt.hashSync(pass, 10),
+                admin: true,
+                groups: [],
+                permissions: {}
+            });
         });
 
         console.log(`default admin password: ${pass}`);
         console.log("saved to ./default_admin_pass.txt, don't share it and change it asap");
-        
+
         writeFileSync("./data/default_admin_pass.txt", pass);
     }
 };

src/lib/server/db/db.ts

@@ -1,4 +1,18 @@
-import { drizzle } from "drizzle-orm/libsql";
-import * as schema from "./schema/_index";
+import { JSONFilePreset } from "lowdb/node";
+import type { User } from "./types/user";
+import type { Device } from "./types/device";
+import type { Group } from "./types/group";
 
-export const db = drizzle("file:./data/db.sqlite", { schema });
+type Data = {
+    users: User[],
+    groups: Group[],
+    devices: Device[],
+};
+
+const defaultData: Data = {
+    users: [],
+    groups: [],
+    devices: [],
+};
+
+export const db = await JSONFilePreset<Data>("./data/db.json", defaultData);

src/lib/server/db/schema/_index.ts

@@ -1,7 +0,0 @@
-export * from "./users";
-export * from "./permissions";
-export * from "./groups";
-export * from "./groupsPermissions";
-export * from "./usersGroups";
-export * from "./usersPermissions";
-export * from "./devices";

src/lib/server/db/schema/devices.ts

@@ -1,10 +0,0 @@
-import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-export const devices = sqliteTable("devices", {
-    id: int().primaryKey({ autoIncrement: true }),
-    name: text().notNull().unique(),
-    mac: text().notNull().unique(),
-    ip: text().notNull(),
-    port: int().notNull(),
-    packets: int().notNull().default(3),
-});

src/lib/server/db/schema/groups.ts

@@ -1,14 +0,0 @@
-import { relations } from "drizzle-orm";
-import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import { groupsPermissions } from "./groupsPermissions";
-import { usersGroups } from "./usersGroups";
-
-export const groups = sqliteTable("groups", {
-    id: int().primaryKey({ autoIncrement: true }),
-    name: text().notNull().unique(),
-});
-
-export const groupsRelations = relations(groups, ({ many }) => ({
-    groupsPermissions: many(groupsPermissions),
-    usersGroups: many(usersGroups),
-}));

src/lib/server/db/schema/groupsPermissions.ts

@@ -1,22 +0,0 @@
-import { int, primaryKey, sqliteTable } from "drizzle-orm/sqlite-core";
-import { groups } from "./groups";
-import { permissions } from "./permissions";
-import { relations } from "drizzle-orm";
-
-export const groupsPermissions = sqliteTable("groups_permissions", {
-    groupId: int().notNull().references(() => groups.id),
-    permissionId: int().notNull().references(() => permissions.id),
-}, (t) => [
-    primaryKey({ columns: [t.groupId, t.permissionId] }),
-]);
-
-export const groupsPermissionsRelations = relations(groupsPermissions, ({ one }) => ({
-    group: one(groups, {
-        fields: [groupsPermissions.groupId],
-        references: [groups.id],
-    }),
-    permission: one(permissions, {
-        fields: [groupsPermissions.permissionId],
-        references: [permissions.id],
-    }),
-}));

src/lib/server/db/schema/permissions.ts

@@ -1,16 +0,0 @@
-import { relations } from "drizzle-orm";
-import { int, sqliteTable } from "drizzle-orm/sqlite-core";
-import { devices } from "./devices";
-
-export const permissions = sqliteTable("permissions", {
-    id: int().primaryKey({ autoIncrement: true }),
-    deviceId: int().notNull(),
-    flags: int().notNull(),
-});
-
-export const permissionsRelations = relations(permissions, ({ one }) => ({
-    device: one(devices, {
-        fields: [permissions.deviceId],
-        references: [devices.id],
-    }),
-}));

src/lib/server/db/schema/users.ts

@@ -1,16 +0,0 @@
-import { relations } from "drizzle-orm";
-import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import { usersPermissions } from "./usersPermissions";
-import { usersGroups } from "./usersGroups";
-
-export const users = sqliteTable("users", {
-    id: int().primaryKey({ autoIncrement: true }),
-    name: text().notNull().unique(),
-    admin: int({ mode: "boolean" }).notNull().default(false),
-    password: text().notNull(),
-});
-
-export const usersRelations = relations(users, ({ many }) => ({
-    usersPermissions: many(usersPermissions),
-    usersGroups: many(usersGroups),
-}));

src/lib/server/db/schema/usersGroups.ts

@@ -1,22 +0,0 @@
-import { relations } from "drizzle-orm";
-import { int, primaryKey, sqliteTable } from "drizzle-orm/sqlite-core";
-import { users } from "./users";
-import { groups } from "./groups";
-
-export const usersGroups = sqliteTable("users_groups", {
-    userId: int().notNull().references(() => users.id),
-    groupId: int().notNull().references(() => groups.id),
-}, (t) => [
-    primaryKey({ columns: [t.userId, t.groupId] }),
-]);
-
-export const usersGroupsRelations = relations(usersGroups, ({ one }) => ({
-    user: one(users, {
-        fields: [usersGroups.userId],
-        references: [users.id],
-    }),
-    group: one(groups, {
-        fields: [usersGroups.groupId],
-        references: [groups.id],
-    }),
-}));

src/lib/server/db/schema/usersPermissions.ts

@@ -1,22 +0,0 @@
-import { relations } from "drizzle-orm";
-import { int, primaryKey, sqliteTable } from "drizzle-orm/sqlite-core";
-import { users } from "./users";
-import { permissions } from "./permissions";
-
-export const usersPermissions = sqliteTable("users_permissions", {
-    userId: int().notNull().references(() => users.id),
-    permissionId: int().notNull().references(() => permissions.id),
-}, (t) => [
-    primaryKey({ columns: [t.userId, t.permissionId] }),
-]);
-
-export const usersPermissionsRelations = relations(usersPermissions, ({ one }) => ({
-    user: one(users, {
-        fields: [usersPermissions.userId],
-        references: [users.id],
-    }),
-    permission: one(permissions, {
-        fields: [usersPermissions.permissionId],
-        references: [permissions.id],
-    }),
-}));

src/lib/server/db/types/device.ts

@@ -0,0 +1,8 @@
+export type Device = {
+    id: string,
+    name: string,
+    mac: string,
+    ip: string,
+    port: number,
+    packets: number
+}

src/lib/server/db/types/group.ts

@@ -0,0 +1,7 @@
+import type { Permission } from "./permission"
+
+export type Group = {
+    id: string,
+    name: string,
+    permissions: { [key: string]: Permission }
+}

src/lib/server/db/types/permission.ts

@@ -0,0 +1,3 @@
+export type Permission = {
+    wake: boolean;
+}

src/lib/server/db/types/user.ts

@@ -0,0 +1,11 @@
+import type { Group } from "./group"
+import type { Permission } from "./permission"
+
+export type User = {
+    id: string,
+    name: string,
+    password: string,
+    admin: boolean
+    groups: Group[],
+    permissions: { [key: string]: Permission }
+}

src/lib/server/sessions.ts

@@ -1,9 +1,9 @@
 import { nanoid } from "nanoid";
-import type { groups, permissions, users } from "./db/schema/_index";
 import { db } from "./db/db";
+import type { User } from "./db/types/user";
 
 type SessionData = {
-    userId: number,
+    userId: string,
     userAgent: string,
 };
 
@@ -16,12 +16,7 @@ export function createSession(data: SessionData) {
     return token;
 };
 
-export type FullUser = typeof users.$inferSelect & {
-    permissions: typeof permissions.$inferSelect[],
-    groups: typeof groups.$inferSelect & { permissions: typeof permissions.$inferSelect[] }[]
-};
-
-export async function getUserFromSession(sessionId?: string): Promise<typeof users.$inferSelect | undefined> {
+export async function getUserFromSession(sessionId?: string): Promise<User | undefined> {
     if (!sessionId) {
         return undefined;
     }
@@ -34,37 +29,7 @@ export async function getUserFromSession(sessionId?: string): Promise<typeof use
 
     // what in the nested fuck is this shit 
     // I thought ORMs made it easier but they just make queries more ridiculous
-    const user = await db.query.users.findFirst({
-        where: (users, { eq }) => eq(users.id, data.userId),
-        with: {
-            usersGroups: {
-                with: {
-                    group: {
-                        with: {
-                            groupsPermissions: {
-                                with: {
-                                    permission: {
-                                        with: {
-                                            device: true
-                                        }
-                                    },
-                                }
-                            }
-                        }
-                    }
-                }
-            },
-            usersPermissions: {
-                with: {
-                    permission: {
-                        with: {
-                            device: true
-                        }
-                    },
-                }
-            }
-        }
-    });
+    const user = db.data.users.find(user => user.id === data.userId);
 
     return user;
 };

src/routes/dashboard/+page.server.ts

@@ -1,15 +1,15 @@
 import { db } from "$lib/server/db/db";
-import type { FullUser } from "$lib/server/sessions";
+import type { User } from "$lib/server/db/types/user";
 import type { ServerLoad } from "@sveltejs/kit";
 
 export const load: ServerLoad = async ({ parent }) => {
-    const { user } = await parent() as { user: FullUser };
+    const { user } = await parent() as { user: User };
     
-    if (user.admin) {
-        console.log(user);
-
-        return {
-            devices: await db.query.devices.findMany(),
-        }
+    return {
+        devices: user.admin ? db.data.devices : 
+            db.data.devices.filter(device => 
+                Object.keys(user.permissions).includes(device.id) || 
+                user.groups.some(group => Object.keys(group.permissions).includes(device.id))
+            ),
     }
 };

src/routes/login/+page.server.ts

@@ -20,9 +20,7 @@ export const actions = {
             }
         }
 
-        const user = await db.query.users.findFirst({
-            where: (users, { eq }) => eq(users.name, username),
-        });
+        const user = db.data.users.find(user => user.name === username);
 
         if (!user || !bcrypt.compareSync(password, user.password)) {
             return {