recator placement of code

backend/db/db.controller.ts

@@ -0,0 +1,16 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+const dbURL = `postgres://${process.env.DATABASE_USER}:${process.env.DATABASE_PASSWORD}@${process.env.DATABASE_HOST}:${process.env.DATABASE_PORT}/${process.env.DATABASE_DB}`;
+
+const queryClient = postgres(dbURL, {
+	max: 10,
+	idle_timeout: 60,
+	connect_timeout: 30,
+	max_lifetime: 1000 * 6 * 5,
+	onnotice: (n) => {
+		console.info("PG notice: ", n.message);
+	},
+});
+
+export const db = drizzle({ client: queryClient });

backend/db/dbBackup.contoller.ts

@@ -0,0 +1,6 @@
+/**
+ * while in client mode we will be connected directly to the postgres and do a nightly backup.
+ * we will only keep tables relevant, like silo data, inv history, manualPrinting, notifications, printerData,prodlabels, quality request, rfid tags, roles, serverData,...etc
+ * keeping only the last 7 backups
+ *
+ */

backend/db/schema/auth.schema.ts

@@ -0,0 +1,156 @@
+import { relations } from "drizzle-orm";
+import {
+	boolean,
+	index,
+	integer,
+	pgTable,
+	text,
+	timestamp,
+} from "drizzle-orm/pg-core";
+
+export const user = pgTable("user", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: boolean("email_verified").default(false).notNull(),
+	image: text("image"),
+	createdAt: timestamp("created_at").defaultNow().notNull(),
+	updatedAt: timestamp("updated_at")
+		.defaultNow()
+		.$onUpdate(() => /* @__PURE__ */ new Date())
+		.notNull(),
+	role: text("role"),
+	banned: boolean("banned").default(false),
+	banReason: text("ban_reason"),
+	banExpires: timestamp("ban_expires"),
+	username: text("username").unique(),
+	displayUsername: text("display_username"),
+});
+
+export const session = pgTable(
+	"session",
+	{
+		id: text("id").primaryKey(),
+		expiresAt: timestamp("expires_at").notNull(),
+		token: text("token").notNull().unique(),
+		createdAt: timestamp("created_at").defaultNow().notNull(),
+		updatedAt: timestamp("updated_at")
+			.$onUpdate(() => /* @__PURE__ */ new Date())
+			.notNull(),
+		ipAddress: text("ip_address"),
+		userAgent: text("user_agent"),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		impersonatedBy: text("impersonated_by"),
+	},
+	(table) => [index("session_userId_idx").on(table.userId)],
+);
+
+export const account = pgTable(
+	"account",
+	{
+		id: text("id").primaryKey(),
+		accountId: text("account_id").notNull(),
+		providerId: text("provider_id").notNull(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		accessToken: text("access_token"),
+		refreshToken: text("refresh_token"),
+		idToken: text("id_token"),
+		accessTokenExpiresAt: timestamp("access_token_expires_at"),
+		refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+		scope: text("scope"),
+		password: text("password"),
+		createdAt: timestamp("created_at").defaultNow().notNull(),
+		updatedAt: timestamp("updated_at")
+			.$onUpdate(() => /* @__PURE__ */ new Date())
+			.notNull(),
+	},
+	(table) => [index("account_userId_idx").on(table.userId)],
+);
+
+export const verification = pgTable(
+	"verification",
+	{
+		id: text("id").primaryKey(),
+		identifier: text("identifier").notNull(),
+		value: text("value").notNull(),
+		expiresAt: timestamp("expires_at").notNull(),
+		createdAt: timestamp("created_at").defaultNow().notNull(),
+		updatedAt: timestamp("updated_at")
+			.defaultNow()
+			.$onUpdate(() => /* @__PURE__ */ new Date())
+			.notNull(),
+	},
+	(table) => [index("verification_identifier_idx").on(table.identifier)],
+);
+
+export const jwks = pgTable("jwks", {
+	id: text("id").primaryKey(),
+	publicKey: text("public_key").notNull(),
+	privateKey: text("private_key").notNull(),
+	createdAt: timestamp("created_at").notNull(),
+	expiresAt: timestamp("expires_at"),
+});
+
+export const apikey = pgTable(
+	"apikey",
+	{
+		id: text("id").primaryKey(),
+		name: text("name"),
+		start: text("start"),
+		prefix: text("prefix"),
+		key: text("key").notNull(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		refillInterval: integer("refill_interval"),
+		refillAmount: integer("refill_amount"),
+		lastRefillAt: timestamp("last_refill_at"),
+		enabled: boolean("enabled").default(true),
+		rateLimitEnabled: boolean("rate_limit_enabled").default(true),
+		rateLimitTimeWindow: integer("rate_limit_time_window").default(86400000),
+		rateLimitMax: integer("rate_limit_max").default(10),
+		requestCount: integer("request_count").default(0),
+		remaining: integer("remaining"),
+		lastRequest: timestamp("last_request"),
+		expiresAt: timestamp("expires_at"),
+		createdAt: timestamp("created_at").notNull(),
+		updatedAt: timestamp("updated_at").notNull(),
+		permissions: text("permissions"),
+		metadata: text("metadata"),
+	},
+	(table) => [
+		index("apikey_key_idx").on(table.key),
+		index("apikey_userId_idx").on(table.userId),
+	],
+);
+
+export const userRelations = relations(user, ({ many }) => ({
+	sessions: many(session),
+	accounts: many(account),
+	apikeys: many(apikey),
+}));
+
+export const sessionRelations = relations(session, ({ one }) => ({
+	user: one(user, {
+		fields: [session.userId],
+		references: [user.id],
+	}),
+}));
+
+export const accountRelations = relations(account, ({ one }) => ({
+	user: one(user, {
+		fields: [account.userId],
+		references: [user.id],
+	}),
+}));
+
+export const apikeyRelations = relations(apikey, ({ one }) => ({
+	user: one(user, {
+		fields: [apikey.userId],
+		references: [user.id],
+	}),
+}));

backend/db/schema/datamart.schema.ts

@@ -0,0 +1,31 @@
+import {
+	boolean,
+	integer,
+	pgTable,
+	text,
+	timestamp,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type { z } from "zod";
+
+export const datamart = pgTable("datamart", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	name: text("name").unique(),
+	description: text("description").notNull(),
+	query: text("query"),
+	version: integer("version").default(1).notNull(),
+	active: boolean("active").default(true),
+	options: text("options").default(""),
+	public: boolean("public_access").default(false),
+	add_date: timestamp("add_date").defaultNow(),
+	add_user: text("add_user").default("lst-system"),
+	upd_date: timestamp("upd_date").defaultNow(),
+	upd_user: text("upd_user").default("lst-system"),
+});
+
+export const datamartSchema = createSelectSchema(datamart);
+export const newDataMartSchema = createInsertSchema(datamart);
+
+export type Datamart = z.infer<typeof datamartSchema>;
+export type NewDatamart = z.infer<typeof newDataMartSchema>;

backend/db/schema/logs.schema.ts

@@ -0,0 +1,28 @@
+import {
+	boolean,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type { z } from "zod";
+
+export const logs = pgTable("logs", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	level: text("level"),
+	module: text("module").notNull(),
+	subModule: text("subModule"),
+	message: text("message").notNull(),
+	stack: jsonb("stack").default([]),
+	checked: boolean("checked").default(false),
+	hostname: text("hostname"),
+	createdAt: timestamp("created_at").defaultNow(),
+});
+
+export const logSchema = createSelectSchema(logs);
+export const newLogSchema = createInsertSchema(logs);
+
+export type Log = z.infer<typeof logSchema>;
+export type NewLog = z.infer<typeof newLogSchema>;

backend/db/schema/opendock.schema.ts

@@ -0,0 +1,25 @@
+import {
+	integer,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type { z } from "zod";
+
+export const opendockApt = pgTable("opendock.apt", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	release: integer("release").unique(),
+	openDockAptId: text("open_dock_apt_id").notNull(),
+	appointment: jsonb("appointment").default([]),
+	upd_date: timestamp("upd_date").defaultNow(),
+	createdAt: timestamp("created_at").defaultNow(),
+});
+
+export const opendockAptSchema = createSelectSchema(opendockApt);
+export const newOpendockAptSchema = createInsertSchema(opendockApt);
+
+export type OpendockApt = z.infer<typeof opendockAptSchema>;
+export type NewOpendockApt = z.infer<typeof newOpendockAptSchema>;

backend/db/schema/settings.schema.ts

@@ -0,0 +1,43 @@
+import {
+	boolean,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	uniqueIndex,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+
+import { z } from "zod";
+
+export const settings = pgTable(
+	"settings",
+	{
+		id: uuid("settings_id").defaultRandom().primaryKey(),
+		name: text("name").notNull(),
+		value: text("value").notNull(), // this is used in junction with active, only needed if the setting isn't a bool
+		description: text("description"),
+		moduleName: text("moduleName"), // what part of lst dose it belong to this is used to split the settings out later
+		active: boolean("active").default(true),
+		roles: jsonb("roles").notNull().default(["systemAdmin"]), // role or roles to see this goes along with the moduleName, need to have a x role in module to see this setting.
+		add_User: text("add_User").default("LST_System").notNull(),
+		add_Date: timestamp("add_Date").defaultNow(),
+		upd_user: text("upd_User").default("LST_System").notNull(),
+		upd_date: timestamp("upd_date").defaultNow(),
+	},
+	(table) => [
+		// uniqueIndex('emailUniqueIndex').on(sql`lower(${table.email})`),
+		uniqueIndex("name").on(table.name),
+	],
+);
+
+export const settingSchema = createSelectSchema(settings);
+export const newSettingSchema = createInsertSchema(settings, {
+	name: z.string().min(3, {
+		message: "The name of the setting must be longer than 3 letters",
+	}),
+});
+
+export type Setting = z.infer<typeof settingSchema>;
+export type NewSetting = z.infer<typeof newSettingSchema>;