reorg to domain and api

This commit is contained in:
Alex Holliday committed 2026-06-09 12:34:15 -07:00
1 parent 0fb210e9e1
commit d022f7d849
190 files changed
+643 -830

No files matched your search

@@ -0,0 +1,11 @@
import type { Settings, SettingsUpdate } from "@/domain/app-settings/app-settings.type.js";
export interface ISettingsRepository {
// create
create(settings: Partial<Settings>): Promise<Settings>;
// fetch
findSingleton(): Promise<Settings | null>;
// update
update(settings: SettingsUpdate): Promise<Settings>;
// delete
deleteLegacy: () => Promise<boolean>;
}
@@ -0,0 +1,51 @@
import { Schema, model, type Types } from "mongoose";
import type { Settings, SettingsThresholds } from "@/domain/app-settings/app-settings.type.js";
interface AppSettingsDocument extends Omit<Settings, "id" | "createdAt" | "updatedAt"> {
_id: Types.ObjectId;
createdAt: Date;
updatedAt: Date;
}
const thresholdsSchema = new Schema<SettingsThresholds>(
{
cpu: { type: Number },
memory: { type: Number },
disk: { type: Number },
temperature: { type: Number },
},
{ _id: false }
);
const AppSettingsSchema = new Schema<AppSettingsDocument>(
{
checkTTL: { type: Number, default: 30 },
language: { type: String, default: "gb" },
jwtSecret: { type: String },
pagespeedApiKey: { type: String },
systemEmailHost: { type: String },
systemEmailPort: { type: Number },
systemEmailAddress: { type: String },
systemEmailDisplayName: { type: String },
systemEmailPassword: { type: String },
systemEmailUser: { type: String },
systemEmailConnectionHost: { type: String, default: "localhost" },
systemEmailTLSServername: { type: String },
systemEmailSecure: { type: Boolean, default: false },
systemEmailPool: { type: Boolean, default: false },
systemEmailIgnoreTLS: { type: Boolean, default: false },
systemEmailRequireTLS: { type: Boolean, default: false },
systemEmailRejectUnauthorized: { type: Boolean, default: true },
showURL: { type: Boolean, default: false },
singleton: { type: Boolean, required: true, unique: true, default: true },
version: { type: Number, default: 1 },
globalThresholds: { type: thresholdsSchema },
},
{ timestamps: true }
);
const AppSettingsModel = model<AppSettingsDocument>("AppSettings", AppSettingsSchema);
export type { AppSettingsDocument };
export { AppSettingsModel };
export default AppSettingsModel;
@@ -0,0 +1,99 @@
import mongoose, { type UpdateQuery } from "mongoose";
import { ISettingsRepository } from "@/domain/app-settings/app-settings-repository.interface.js";
import type { Settings, SettingsUpdate } from "@/domain/app-settings/app-settings.type.js";
import { AppSettingsModel, type AppSettingsDocument } from "@/domain/app-settings/app-settings.model.js";
class MongoSettingsRepository implements ISettingsRepository {
private toStringId = (value?: mongoose.Types.ObjectId | string | null): string => {
if (!value) {
return "";
}
return value instanceof mongoose.Types.ObjectId ? value.toString() : String(value);
};
private toDateString = (value?: Date | string | null): string => {
if (!value) {
return new Date(0).toISOString();
}
return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
};
protected toEntity = (doc: AppSettingsDocument): Settings => {
return {
id: this.toStringId(doc._id),
checkTTL: doc.checkTTL,
language: doc.language,
jwtSecret: doc.jwtSecret ?? undefined,
pagespeedApiKey: doc.pagespeedApiKey ?? undefined,
systemEmailHost: doc.systemEmailHost ?? undefined,
systemEmailPort: doc.systemEmailPort ?? undefined,
systemEmailAddress: doc.systemEmailAddress ?? undefined,
systemEmailPassword: doc.systemEmailPassword ?? undefined,
systemEmailUser: doc.systemEmailUser ?? undefined,
systemEmailConnectionHost: doc.systemEmailConnectionHost ?? undefined,
systemEmailTLSServername: doc.systemEmailTLSServername ?? undefined,
systemEmailSecure: doc.systemEmailSecure ?? false,
systemEmailPool: doc.systemEmailPool ?? false,
systemEmailIgnoreTLS: doc.systemEmailIgnoreTLS ?? false,
systemEmailRequireTLS: doc.systemEmailRequireTLS ?? false,
systemEmailRejectUnauthorized: doc.systemEmailRejectUnauthorized ?? true,
showURL: doc.showURL ?? false,
singleton: doc.singleton,
version: doc.version ?? 1,
globalThresholds: doc.globalThresholds ?? undefined,
createdAt: this.toDateString(doc.createdAt),
updatedAt: this.toDateString(doc.updatedAt),
};
};
create = async (settings: Partial<Settings>) => {
const newSettings = await AppSettingsModel.create(settings);
return this.toEntity(newSettings);
};
findSingleton = async () => {
const settings = await AppSettingsModel.findOne({ singleton: true }).select("-__v -_id -createdAt -updatedAt -singleton").lean();
if (!settings) {
return null;
}
return this.toEntity(settings);
};
update = async (settings: SettingsUpdate) => {
const $set: Record<string, unknown> = {};
const $unset: Record<string, string> = {};
// Iterate through settings and separate into $set and $unset
Object.entries(settings).forEach(([key, value]) => {
if (value === undefined || value === null) {
$unset[key] = "";
} else {
$set[key] = value;
}
});
const update: UpdateQuery<AppSettingsDocument> = {
...(Object.keys($set).length > 0 && { $set }),
...(Object.keys($unset).length > 0 && { $unset }),
};
await AppSettingsModel.findOneAndUpdate({}, update, {
upsert: true,
});
const updatedSettings = await AppSettingsModel.findOneAndUpdate({}, update, {
upsert: true,
new: true,
projection: "-__v -_id -createdAt -updatedAt -singleton",
});
return this.toEntity(updatedSettings);
};
deleteLegacy = async () => {
const res = await AppSettingsModel.deleteMany({ version: { $exists: false } });
return res.deletedCount > 0;
};
}
export default MongoSettingsRepository;
+102
View File
@@ -0,0 +1,102 @@
import { ISettingsRepository } from "@/domain/app-settings/app-settings-repository.interface.js";
import { Settings, SettingsUpdate, type DbType, type QueueMode, type QueueType } from "@/domain/app-settings/app-settings.type.js";
import { AppError } from "@/utils/AppError.js";
import { ValidatedEnv } from "@/config/envValidation.js";
import type { StringValue } from "ms";
const SERVICE_NAME = "SettingsService";
export type EnvConfig = {
jwtSecret: string;
jwtTTL: StringValue;
nodeEnv: string;
logLevel: string;
clientHost: string;
dbConnectionString: string;
dbType: DbType;
queueType: QueueType;
queueMode: QueueMode;
statusPageThemesEnabled: boolean;
};
export interface ISettingsService {
readonly serviceName: string;
loadSettings(): EnvConfig;
getSettings(): EnvConfig;
areStatusPageThemesEnabled(): boolean;
getDBSettings(): Promise<Settings>;
updateDbSettings(newSettings: SettingsUpdate): Promise<Settings>;
}
export class SettingsService implements ISettingsService {
static SERVICE_NAME = SERVICE_NAME;
private settings: EnvConfig;
private settingsRepository: ISettingsRepository | null = null;
constructor(env: ValidatedEnv) {
this.settings = {
jwtSecret: env.JWT_SECRET,
jwtTTL: env.TOKEN_TTL as StringValue,
nodeEnv: env.NODE_ENV,
logLevel: env.LOG_LEVEL,
clientHost: env.CLIENT_HOST,
dbConnectionString: env.DB_CONNECTION_STRING,
dbType: env.DB_TYPE,
queueType: env.QUEUE_TYPE,
queueMode: env.QUEUE_MODE,
statusPageThemesEnabled: env.STATUS_PAGE_THEMES_ENABLED,
};
}
setRepository(settingsRepository: ISettingsRepository) {
this.settingsRepository = settingsRepository;
}
get serviceName() {
return SettingsService.SERVICE_NAME;
}
loadSettings() {
return this.settings;
}
getSettings() {
return this.settings;
}
areStatusPageThemesEnabled() {
return this.settings.statusPageThemesEnabled;
}
private getRepository(): ISettingsRepository {
if (!this.settingsRepository) {
throw new AppError({
message: "Settings repository not initialized. Call setRepository() after DB connect.",
status: 500,
service: SERVICE_NAME,
});
}
return this.settingsRepository;
}
updateDbSettings = async (newSettings: SettingsUpdate) => {
return await this.getRepository().update(newSettings);
};
getDBSettings = async () => {
const repo = this.getRepository();
// Remove any old settings
await repo.deleteLegacy();
let settings = await repo.findSingleton();
if (settings === null) {
await repo.create({});
settings = await repo.findSingleton();
}
if (!settings) {
throw new AppError({ message: "Settings not found", status: 500 });
}
return settings;
};
}
@@ -0,0 +1,63 @@
export const DbTypes = ["mongodb"] as const;
export type DbType = (typeof DbTypes)[number];
export const QueueTypes = ["lessSimpleQueue", "superSimpleQueue"] as const;
export type QueueType = (typeof QueueTypes)[number];
export const QueueModes = ["primary", "worker"] as const;
export type QueueMode = (typeof QueueModes)[number];
export interface SettingsThresholds {
cpu?: number;
memory?: number;
disk?: number;
temperature?: number;
}
export type SettingsUpdate = {
[K in keyof Settings]?: Settings[K] | null;
};
export interface Settings {
id: string;
checkTTL: number;
language: string;
jwtSecret?: string;
pagespeedApiKey?: string;
systemEmailHost?: string;
systemEmailPort?: number;
systemEmailAddress?: string;
systemEmailDisplayName?: string;
systemEmailPassword?: string;
systemEmailUser?: string;
systemEmailConnectionHost?: string;
systemEmailTLSServername?: string;
systemEmailSecure: boolean;
systemEmailPool: boolean;
systemEmailIgnoreTLS: boolean;
systemEmailRequireTLS: boolean;
systemEmailRejectUnauthorized: boolean;
showURL: boolean;
singleton: boolean;
version: number;
globalThresholds?: SettingsThresholds;
createdAt: string;
updatedAt: string;
}
export type EmailTransportConfig = Pick<
Settings,
| "systemEmailHost"
| "systemEmailPort"
| "systemEmailAddress"
| "systemEmailDisplayName"
| "systemEmailPassword"
| "systemEmailUser"
| "systemEmailConnectionHost"
| "systemEmailTLSServername"
| "systemEmailSecure"
| "systemEmailPool"
| "systemEmailIgnoreTLS"
| "systemEmailRequireTLS"
| "systemEmailRejectUnauthorized"
>;