SikongJueluo
/
FPGA_WebLab
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add error type and more functions in database

This commit is contained in:
SikongJueluo 2025-03-25 21:16:33 +08:00
parent 8fa594159f
commit 4fb4c08044
No known key found for this signature in database
4 changed files with 270 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
flake.nix
View File

@ -17,7 +17,7 @@
bun
sqlite
sqls
dbeaver-bin
sql-studio
# LSP
typescript-language-server

43
server/common.ts
View File

@ -1,4 +1,5 @@
import _ from "lodash"
import { Option, Some, None } from "ts-results-es";
import { z } from "zod";
export const uint8 = z.number().nonnegative().lt(Math.pow(2, 8))
@ -23,6 +24,48 @@ export namespace fun {
export function randomFromArray(array: Array<any>) {
return array[_.random(0, array.length - 1, false)]
}
export function isStringArray(obj: any): obj is Array<string> {
return z.string().array().safeParse(obj).success
}
export function isNumberArray(obj: any): obj is Array<number> {
return z.number().array().safeParse(obj).success
}
export function sqlConditionFromArray(
columnName: string,
array: Array<string>,
type: "AND" | "OR"
): Option<string> {
let condition: string = ""
const len = array.length
if (len == 0) {
return None
}
for (let i = 0; i < len; i++) {
condition.concat(`${columnName}=${array[i]}`)
if (i != len - 1) {
condition.concat(` ${type} `)
}
}
return new Some(condition)
}
export function sqlConditionFromString(
columnName: string,
str: string,
type: "AND" | "OR",
delimiter: string = " "
): Option<string> {
if (str.length == 0) {
return None
}
const array = str.split(delimiter)
return sqlConditionFromArray(columnName, array, type)
}
}

31
server/database.test.ts
View File

@ -1,8 +1,9 @@
import { test, expect } from "bun:test"
import * as db from "./database.ts"
import _ from "lodash"
import _, { rearg } from "lodash"
import { None, Ok, Option, Some } from "ts-results-es"
// Test basic function for database
test("DataBase", () => {
const allTables = db.allTables()
expect(allTables).toBeArray()
@ -11,17 +12,17 @@ test("DataBase", () => {
expect(db.UserTable.countAll()).toBe(0)
})
test("Board Table", () => {
const boardsNumber = 10
const rooms = ["A1", "A1", "A1", "A1", "A1", "A2", "A2", "A2", "A2", "A2"]
// Try to find something empty
// Test Boards table function
const boardsNumber = 10
const rooms = ["A1", "A1", "A1", "A1", "A1", "A2", "A2", "A2", "A2", "A2"]
test("Find something empty", () => {
const findEmptyByID = db.BoardTable.find(_.random(0, boardsNumber))
expect(findEmptyByID).toEqual(Ok(None))
const findEmptyByName = db.BoardTable.find("Hello", "World")
expect(findEmptyByName).toEqual(Ok(None))
})
test("Add some boards", () => {
const boardsArray: Array<db.Board> = []
for (let i = 0; i < boardsNumber; i++) {
boardsArray.push({
@ -32,9 +33,16 @@ test("Board Table", () => {
port: i,
})
}
db.BoardTable.addFromArray(boardsArray)
const retAdd = db.BoardTable.addFromArray(boardsArray)
const isAddOk = retAdd.isOk()
expect(isAddOk).toBeTrue()
})
// Test Find
test("Get boards table column unique element", () => {
expect(db.BoardTable.rooms().unwrap()).toEqual(["A1", "A2"])
})
test("Find something from boards table", () => {
expect(db.BoardTable.find(1)).toEqual(Ok(Some({
id: 1,
name: `Board ${1}`,
@ -49,10 +57,9 @@ test("Board Table", () => {
ipv4: `192.168.172.${3}`,
port: 3,
} as db.Board)))
})
// Test Count
test("Get count of elements from boards table", () => {
expect(db.BoardTable.countByName("Board 1")).toBe(1)
expect(db.BoardTable.countByRoom("A1")).toBe(5)
})

235
server/database.ts
View File

@ -2,10 +2,23 @@ import { Database, type Changes } from "bun:sqlite";
import _ from "lodash";
import { Ok, Err, Result, None, Some, Option } from "ts-results-es";
import { z } from "zod";
import { fun } from "./common";
const db = new Database("lab.sqlite", { strict: true })
initDB(db);
// Error Type
export const BOARD_ERR_WRONG_TYPE = "Wrong type"
export const BOARD_ERR_NO_BOARDS = "No such Boards"
export const BOARD_ERR_ID_CONFLICT = "ID conflict"
export const BOARD_ERR_NAME_CONFLICT = "Name conflict in one room"
export type BoardErrorType = (
typeof BOARD_ERR_WRONG_TYPE |
typeof BOARD_ERR_NO_BOARDS |
typeof BOARD_ERR_ID_CONFLICT |
typeof BOARD_ERR_NAME_CONFLICT
)
const boardSchema = z.object({
id: z.number().nonnegative(),
@ -21,11 +34,20 @@ const boardSchema = z.object({
})
export type Board = z.infer<typeof boardSchema>
export type BoardColumn = keyof Board
export function isBoard(obj: any): obj is Board {
return boardSchema.safeParse(obj).success
}
export function isBoardArray(obj: any): obj is Array<Board> {
return boardSchema.array().safeParse(obj).success
}
export function isBoardColumn(obj: any): obj is BoardColumn {
return boardSchema.keyof().safeParse(obj).success
}
const userSchema = z.object({
id: z.number().nonnegative(),
name: z.string(),
@ -36,11 +58,19 @@ const userSchema = z.object({
})
export type User = z.infer<typeof userSchema>
export type UserColumn = keyof User
export function isUser(obj: any): obj is User {
return userSchema.safeParse(obj).success
}
export function isUserArray(obj: any): obj is Array<User> {
return userSchema.array().safeParse(obj).success
}
export function isUserColumn(obj: any): obj is UserColumn {
return userSchema.keyof().safeParse(obj).success
}
function initDB(db: Database) {
const tables = allTables()
@ -93,9 +123,9 @@ export function tableColumnName(table: string): Array<string> {
export namespace BoardTable {
export function add(board: Board): Result<Changes, "Wrong type" | "ID conflict" | "Name conflict in one room"> {
export function add(board: Board): Result<Changes, BoardErrorType> {
if (!isBoard(board)) {
return new Err("Wrong type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
// Ensure no id conflict
@ -105,9 +135,9 @@ export namespace BoardTable {
} else {
const retID = includes(board.id)
if (retID.isOk()) {
if (retID.value) return new Err("ID conflict")
if (retID.value) return new Err(BOARD_ERR_ID_CONFLICT)
} else {
return new Err("Wrong type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
}
@ -116,7 +146,7 @@ export namespace BoardTable {
const retName = includes(board.name, board.room)
if (retName.isOk()) {
if (retName.value) {
return new Err("Name conflict in one room")
return new Err(BOARD_ERR_NAME_CONFLICT)
}
} else {
return new Err("Wrong type")
@ -126,7 +156,7 @@ export namespace BoardTable {
const query = db.query(`
INSERT INTO Boards VALUES
(${board.id},
'${board.name},
'${board.name}',
'${board.room}',
'${board.ipv4}',
'${_.isUndefined(board.ipv6) ? "NULL" : board.ipv6}',
@ -136,12 +166,14 @@ export namespace BoardTable {
return Ok(query.run())
}
export function addFromArray(array: Array<Board>): Result<Array<Changes>, "Wrong type"> {
export function addFromArray(array: Array<Board>)
: Result<Array<Changes>, BoardErrorType> {
let arrayChanges: Array<Changes> = []
for (const item of array) {
const ret = add(item)
if (ret.isErr()) {
return new Err("Wrong type")
return ret
} else {
arrayChanges.push(ret.value)
}
@ -150,12 +182,16 @@ export namespace BoardTable {
return new Ok(arrayChanges)
}
export function all() {
export function all(): Option<Array<Board>> {
const query = db.query(`SELECT * FROM Boards`)
const boards = query.all()
const ret = query.all()
query.finalize()
return boards
if (isBoardArray(ret)) {
return Some(ret)
} else {
return None
}
}
export function countAll(): number {
@ -173,10 +209,10 @@ export namespace BoardTable {
return query.values()[0][0] as number
}
export function remove(name: string, room: string): Result<Board, "Wrong Type" | "No such Board">
export function remove(id: number): Result<Board, "Wrong Type" | "No such Board">
export function remove(board: Board): Result<Board, "Wrong Type" | "No such Board">
export function remove(arg1: any, arg2?: any): Result<Board, "Wrong Type" | "No such Board"> {
export function remove(name: string, room: string): Result<Board, BoardErrorType>
export function remove(id: number): Result<Board, BoardErrorType>
export function remove(board: Board): Result<Board, BoardErrorType>
export function remove(arg1: any, arg2?: any): Result<Board, BoardErrorType> {
let retBoard
let condition: string
if (isBoard(arg1)) {
@ -189,7 +225,7 @@ export namespace BoardTable {
retBoard = _.cloneDeep(retBoard.value.value)
condition = `id=${arg1}`
} else {
return new Err("No such Board")
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else if (_.isString(arg1) && _.isString(arg2)) {
@ -198,11 +234,11 @@ export namespace BoardTable {
retBoard = _.cloneDeep(retBoard.value.value)
condition = `name=${arg1}`
} else {
return new Err("No such Board")
return new Err(BOARD_ERR_NO_BOARDS)
}
} else {
return new Err("Wrong Type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
const query = db.query(`DELETE FROM Boards WHERE ${condition}`)
@ -211,9 +247,90 @@ export namespace BoardTable {
return new Ok(retBoard)
}
export function find(name: string, room: string): Result<Option<Board>, "Wrong type">
export function find(id: number): Result<Option<Board>, "Wrong type">
export function find(arg1: any, arg2?: any): Result<Option<Board>, "Wrong type"> {
export function removeAll(): Option<Array<Board>> {
const array = all()
const query = db.query(`DELETE FROM Boards`)
query.run()
if (array.isSome()) {
return new Some(array.value)
} else {
return None
}
}
export function removeByCondition(condition: string): Result<Array<Board>, BoardErrorType> {
const rsArr = findByCondition(condition)
if (rsArr.isNone()) {
return new Err(BOARD_ERR_NO_BOARDS)
}
const query = db.query(`DELETE FROM Boards WHERE ${condition}`)
query.run()
return new Ok(rsArr.value)
}
export function removeByValue(columnName: string, val: string | Array<string>)
: Result<Array<Board>, BoardErrorType> {
if (!isBoardColumn(columnName)) {
return new Err(BOARD_ERR_WRONG_TYPE)
}
let condition: string
if (_.isString(val)) {
const retCond = fun.sqlConditionFromString(columnName, val, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else if (fun.isStringArray(val)) {
const retCond = fun.sqlConditionFromArray(columnName, val, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
return removeByCondition(condition)
}
export function removeByName(name: string | Array<string>)
: Result<Array<Board>, BoardErrorType> {
return removeByValue("name", name)
}
export function removeByRoom(room: string | Array<string>)
: Result<Array<Board>, BoardErrorType> {
return removeByValue("room", room)
}
export function rooms(): Option<Array<string>> {
const query = db.query(`SELECT DISTINCT room FROM Boards`)
let rooms: Array<string> = []
const retVal = query.values()
if (retVal.length > 0) {
for (const item of retVal) {
rooms.push(item[0] as string)
}
return new Some(rooms)
} else {
return None
}
}
export function find(name: string, room: string): Result<Option<Board>, BoardErrorType>
export function find(id: number): Result<Option<Board>, BoardErrorType>
export function find(arg1: any, arg2?: any): Result<Option<Board>, BoardErrorType> {
let condition: string
if (_.isNumber(arg1)) {
condition = `id=${arg1}`
@ -222,7 +339,7 @@ export namespace BoardTable {
condition = `name='${arg1}' AND room='${arg2}'`
} else {
return new Err("Wrong type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
const query = db.query(`SELECT * FROM Boards WHERE ${condition}`)
@ -236,9 +353,71 @@ export namespace BoardTable {
}
}
export function includes(name: string, room?: string): Result<boolean, "Wrong type">
export function includes(id: number): Result<boolean, "Wrong type">
export function includes(arg1: any, arg2?: any): Result<boolean, "Wrong type"> {
export function findByName(name: string | Array<string>): Result<Option<Array<Board>>, BoardErrorType> {
let condition: string
if (_.isString(name)) {
const retCond = fun.sqlConditionFromString("name", name, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else if (fun.isStringArray(name)) {
const retCond = fun.sqlConditionFromArray("name", name, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
return new Ok(findByCondition(condition))
}
export function findByCondition(condition: string): Option<Array<Board>> {
const query = db.query(`SELECT * FROM Boards WHERE ${condition}`)
const ret = query.all()
if (isBoardArray(ret)) {
return new Some(ret)
} else {
return None
}
}
export function findByValue(columnName: string, val: string | Array<string>)
: Result<Option<Array<Board>>, BoardErrorType> {
if (!isBoardColumn(columnName)) {
return new Err(BOARD_ERR_WRONG_TYPE)
}
let condition: string
if (_.isString(name)) {
const retCond = fun.sqlConditionFromString("name", name, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else if (fun.isStringArray(name)) {
const retCond = fun.sqlConditionFromArray("name", name, "OR")
if (retCond.isSome()) {
condition = retCond.value
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else {
return new Err(BOARD_ERR_WRONG_TYPE)
}
return new Ok(findByCondition(condition))
}
export function includes(name: string, room?: string): Result<boolean, BoardErrorType>
export function includes(id: number): Result<boolean, BoardErrorType>
export function includes(arg1: any, arg2?: any): Result<boolean, BoardErrorType> {
let condition: string
if (_.isUndefined(arg2)) {
if (_.isNumber(arg1)) {
@ -248,13 +427,13 @@ export namespace BoardTable {
condition = `name='${arg1}'`
} else {
return new Err("Wrong type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
} else {
if (_.isString(arg1) && _.isString(arg2)) {
condition = `name='${arg1} AND room=${arg2}'`
} else {
return new Err("Wrong type")
return new Err(BOARD_ERR_WRONG_TYPE)
}
}