1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// src/lib/items/repository.ts
import db from "@/db/db";
import { Item, ItemOffshoreTop, ItemOffshoreHull, itemOffshoreHull, itemOffshoreTop, items } from "@/db/schema/items";
import {
eq,
inArray,
asc,
desc,
count,
} from "drizzle-orm";
import { PgTransaction } from "drizzle-orm/pg-core";
export type NewItem = typeof items.$inferInsert
/**
* 단건/복수 조회 시 공통으로 사용 가능한 SELECT 함수 예시
* - 트랜잭션(tx)을 받아서 사용하도록 구현
*/
export async function selectItems(
tx: PgTransaction<any, any, any>,
params: {
where?: any; // drizzle-orm의 조건식 (and, eq...) 등
orderBy?: (ReturnType<typeof asc> | ReturnType<typeof desc>)[];
offset?: number;
limit?: number;
}
) {
const { where, orderBy, offset = 0, limit = 10 } = params;
return tx
.select()
.from(items)
.where(where)
.orderBy(...(orderBy ?? []))
.offset(offset)
.limit(limit);
}
/** 총 개수 count */
export async function countItems(
tx: PgTransaction<any, any, any>,
where?: any
) {
const res = await tx.select({ count: count() }).from(items).where(where);
return res[0]?.count ?? 0;
}
/** 단건 Insert 예시 */
export async function insertItem(
tx: PgTransaction<any, any, any>,
data: NewItem // DB와 동일한 insert 가능한 타입
) {
// returning() 사용 시 배열로 돌아오므로 [0]만 리턴
return tx
.insert(items)
.values(data)
.returning({ id: items.id, createdAt: items.createdAt });
}
/** 복수 Insert 예시 */
export async function insertItems(
tx: PgTransaction<any, any, any>,
data: Item[]
) {
return tx.insert(items).values(data).onConflictDoNothing();
}
/** 단건 삭제 */
export async function deleteItemById(
tx: PgTransaction<any, any, any>,
itemId: number
) {
return tx.delete(items).where(eq(items.id, itemId));
}
/** 복수 삭제 */
export async function deleteItemsByIds(
tx: PgTransaction<any, any, any>,
ids: number[]
) {
return tx.delete(items).where(inArray(items.id, ids));
}
/** 전체 삭제 */
export async function deleteAllItems(
tx: PgTransaction<any, any, any>,
) {
return tx.delete(items);
}
/** 단건 업데이트 */
export async function updateItem(
tx: PgTransaction<any, any, any>,
itemId: number,
data: Partial<Item>
) {
return tx
.update(items)
.set(data)
.where(eq(items.id, itemId))
.returning({ id: items.id, createdAt: items.createdAt });
}
/** 복수 업데이트 */
export async function updateItems(
tx: PgTransaction<any, any, any>,
ids: number[],
data: Partial<Item>
) {
return tx
.update(items)
.set(data)
.where(inArray(items.id, ids))
.returning({ id: items.id, createdAt: items.createdAt });
}
export async function findAllItems(): Promise<Item[]> {
return db.select().from(items).orderBy(asc(items.itemCode));
}
export async function findAllOffshoreItems(): Promise<(ItemOffshoreHull | ItemOffshoreTop)[]> {
const hullItems = await db.select().from(itemOffshoreHull);
const topItems = await db.select().from(itemOffshoreTop);
return [...hullItems, ...topItems];
}
|
