@voyantjs/transactions 0.1.1 → 0.3.0

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,EAChB,2BAA2B,EAC3B,uBAAuB,EACvB,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,UAAU,EACV,WAAW,EACX,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACvB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,WAAW,EACX,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACtB,eAAe,EACf,WAAW,EACX,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACtB,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,2BAA2B,EAC3B,uBAAuB,EACvB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,WAAW,EACX,eAAe,EACf,0BAA0B,EAC1B,sBAAsB,EACtB,eAAe,EAChB,MAAM,qBAAqB,CAAA;AAE5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C/B,CAAA"}

package/dist/service.js

@@ -1,597 +1,50 @@
-import { and, asc, desc, eq, ilike, or, sql } from "drizzle-orm";
-import { offerItemParticipants, offerItems, offerParticipants, offers, orderItemParticipants, orderItems, orderParticipants, orders, orderTerms, } from "./schema.js";
-async function paginate(rowsQuery, countQuery, limit, offset) {
-    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
-    return { data, total: countResult[0]?.count ?? 0, limit, offset };
-}
-function normalizeTimestamp(value) {
-    if (value === undefined || value === "")
-        return undefined;
-    if (value === null)
-        return null;
-    return new Date(value);
-}
-function toOfferParticipantResponse(row) {
-    return {
-        id: row.id,
-        offerId: row.offerId,
-        personId: row.personId,
-        participantType: row.participantType,
-        travelerCategory: row.travelerCategory,
-        firstName: row.firstName,
-        lastName: row.lastName,
-        email: row.email,
-        phone: row.phone,
-        preferredLanguage: row.preferredLanguage,
-        isPrimary: row.isPrimary,
-        notes: row.notes,
-        hasTravelIdentity: Boolean(row.identityEncrypted),
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt,
-    };
-}
-function toOrderParticipantResponse(row) {
-    return {
-        id: row.id,
-        orderId: row.orderId,
-        personId: row.personId,
-        participantType: row.participantType,
-        travelerCategory: row.travelerCategory,
-        firstName: row.firstName,
-        lastName: row.lastName,
-        email: row.email,
-        phone: row.phone,
-        preferredLanguage: row.preferredLanguage,
-        isPrimary: row.isPrimary,
-        notes: row.notes,
-        hasTravelIdentity: Boolean(row.identityEncrypted),
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt,
-    };
-}
+import { createOffer, createOfferBundle, createOfferItem, createOfferItemParticipant, createOfferParticipant, deleteOffer, deleteOfferItem, deleteOfferItemParticipant, deleteOfferParticipant, getOfferById, getOfferItemById, getOfferItemParticipantById, getOfferParticipantById, listOfferItemParticipants, listOfferItems, listOfferParticipants, listOffers, updateOffer, updateOfferItem, updateOfferItemParticipant, updateOfferParticipant, } from "./service-offers.js";
+import { createOrder, createOrderItem, createOrderItemParticipant, createOrderParticipant, createOrderTerm, deleteOrder, deleteOrderItem, deleteOrderItemParticipant, deleteOrderParticipant, deleteOrderTerm, getOrderById, getOrderItemById, getOrderItemParticipantById, getOrderParticipantById, getOrderTermById, listOrderItemParticipants, listOrderItems, listOrderParticipants, listOrders, listOrderTerms, updateOrder, updateOrderItem, updateOrderItemParticipant, updateOrderParticipant, updateOrderTerm, } from "./service-orders.js";
 export const transactionsService = {
-    async listOffers(db, query) {
-        const conditions = [];
-        if (query.status)
-            conditions.push(eq(offers.status, query.status));
-        if (query.opportunityId)
-            conditions.push(eq(offers.opportunityId, query.opportunityId));
-        if (query.quoteId)
-            conditions.push(eq(offers.quoteId, query.quoteId));
-        if (query.personId)
-            conditions.push(eq(offers.personId, query.personId));
-        if (query.organizationId)
-            conditions.push(eq(offers.organizationId, query.organizationId));
-        if (query.marketId)
-            conditions.push(eq(offers.marketId, query.marketId));
-        if (query.search) {
-            const term = `%${query.search}%`;
-            conditions.push(or(ilike(offers.offerNumber, term), ilike(offers.title, term)));
-        }
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(offers)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(desc(offers.createdAt)), db.select({ count: sql `count(*)::int` }).from(offers).where(where), query.limit, query.offset);
-    },
-    async getOfferById(db, id) {
-        const [row] = await db.select().from(offers).where(eq(offers.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOffer(db, data) {
-        const { sentAt, acceptedAt, convertedAt, ...rest } = data;
-        const [row] = await db
-            .insert(offers)
-            .values({
-            ...rest,
-            sentAt: normalizeTimestamp(sentAt),
-            acceptedAt: normalizeTimestamp(acceptedAt),
-            convertedAt: normalizeTimestamp(convertedAt),
-        })
-            .returning();
-        return row ?? null;
-    },
-    async createOfferBundle(db, input) {
-        return db.transaction(async (tx) => {
-            const offer = await transactionsService.createOffer(tx, input.offer);
-            if (!offer) {
-                return null;
-            }
-            const participants = [];
-            for (const participant of input.participants ?? []) {
-                const created = await transactionsService.createOfferParticipant(tx, {
-                    ...participant,
-                    offerId: offer.id,
-                });
-                if (!created) {
-                    throw new Error("Failed to create offer participant");
-                }
-                participants.push(created);
-            }
-            const items = [];
-            for (const item of input.items) {
-                const created = await transactionsService.createOfferItem(tx, {
-                    ...item,
-                    offerId: offer.id,
-                });
-                if (!created) {
-                    throw new Error("Failed to create offer item");
-                }
-                items.push(created);
-            }
-            const itemParticipants = [];
-            for (const link of input.itemParticipants ?? []) {
-                const item = items[link.itemIndex];
-                const participant = participants[link.participantIndex];
-                if (!item || !participant) {
-                    throw new Error("Invalid offer item participant link");
-                }
-                const created = await transactionsService.createOfferItemParticipant(tx, {
-                    offerItemId: item.id,
-                    participantId: participant.id,
-                    role: link.role,
-                    isPrimary: link.isPrimary,
-                });
-                if (!created) {
-                    throw new Error("Failed to create offer item participant");
-                }
-                itemParticipants.push(created);
-            }
-            return {
-                offer,
-                participants,
-                items,
-                itemParticipants,
-            };
-        });
-    },
-    async updateOffer(db, id, data) {
-        const { sentAt, acceptedAt, convertedAt, ...rest } = data;
-        const [row] = await db
-            .update(offers)
-            .set({
-            ...rest,
-            sentAt: normalizeTimestamp(sentAt),
-            acceptedAt: normalizeTimestamp(acceptedAt),
-            convertedAt: normalizeTimestamp(convertedAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(offers.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOffer(db, id) {
-        const [row] = await db.delete(offers).where(eq(offers.id, id)).returning({ id: offers.id });
-        return row ?? null;
-    },
-    async listOfferParticipants(db, query) {
-        const conditions = [];
-        if (query.offerId)
-            conditions.push(eq(offerParticipants.offerId, query.offerId));
-        if (query.personId)
-            conditions.push(eq(offerParticipants.personId, query.personId));
-        const where = conditions.length ? and(...conditions) : undefined;
-        const rows = db
-            .select()
-            .from(offerParticipants)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(offerParticipants.createdAt))
-            .then((items) => items.map(toOfferParticipantResponse));
-        return paginate(rows, db.select({ count: sql `count(*)::int` }).from(offerParticipants).where(where), query.limit, query.offset);
-    },
-    async getOfferParticipantById(db, id) {
-        const [row] = await db
-            .select()
-            .from(offerParticipants)
-            .where(eq(offerParticipants.id, id))
-            .limit(1);
-        return row ? toOfferParticipantResponse(row) : null;
-    },
-    async createOfferParticipant(db, data) {
-        const { dateOfBirth, nationality, ...rest } = data;
-        void dateOfBirth;
-        void nationality;
-        const [row] = await db.insert(offerParticipants).values(rest).returning();
-        return row ? toOfferParticipantResponse(row) : null;
-    },
-    async updateOfferParticipant(db, id, data) {
-        const { dateOfBirth, nationality, ...rest } = data;
-        void dateOfBirth;
-        void nationality;
-        const [row] = await db
-            .update(offerParticipants)
-            .set({ ...rest, updatedAt: new Date() })
-            .where(eq(offerParticipants.id, id))
-            .returning();
-        return row ? toOfferParticipantResponse(row) : null;
-    },
-    async deleteOfferParticipant(db, id) {
-        const [row] = await db
-            .delete(offerParticipants)
-            .where(eq(offerParticipants.id, id))
-            .returning({ id: offerParticipants.id });
-        return row ?? null;
-    },
-    async listOfferItems(db, query) {
-        const conditions = [];
-        if (query.offerId)
-            conditions.push(eq(offerItems.offerId, query.offerId));
-        if (query.productId)
-            conditions.push(eq(offerItems.productId, query.productId));
-        if (query.optionId)
-            conditions.push(eq(offerItems.optionId, query.optionId));
-        if (query.unitId)
-            conditions.push(eq(offerItems.unitId, query.unitId));
-        if (query.slotId)
-            conditions.push(eq(offerItems.slotId, query.slotId));
-        if (query.status)
-            conditions.push(eq(offerItems.status, query.status));
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(offerItems)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(offerItems.createdAt)), db.select({ count: sql `count(*)::int` }).from(offerItems).where(where), query.limit, query.offset);
-    },
-    async getOfferItemById(db, id) {
-        const [row] = await db.select().from(offerItems).where(eq(offerItems.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOfferItem(db, data) {
-        const { startsAt, endsAt, ...rest } = data;
-        const [row] = await db
-            .insert(offerItems)
-            .values({
-            ...rest,
-            startsAt: normalizeTimestamp(startsAt),
-            endsAt: normalizeTimestamp(endsAt),
-        })
-            .returning();
-        return row ?? null;
-    },
-    async updateOfferItem(db, id, data) {
-        const { startsAt, endsAt, ...rest } = data;
-        const [row] = await db
-            .update(offerItems)
-            .set({
-            ...rest,
-            startsAt: normalizeTimestamp(startsAt),
-            endsAt: normalizeTimestamp(endsAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(offerItems.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOfferItem(db, id) {
-        const [row] = await db
-            .delete(offerItems)
-            .where(eq(offerItems.id, id))
-            .returning({ id: offerItems.id });
-        return row ?? null;
-    },
-    async listOfferItemParticipants(db, query) {
-        const conditions = [];
-        if (query.offerItemId)
-            conditions.push(eq(offerItemParticipants.offerItemId, query.offerItemId));
-        if (query.participantId)
-            conditions.push(eq(offerItemParticipants.participantId, query.participantId));
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(offerItemParticipants)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(offerItemParticipants.createdAt)), db.select({ count: sql `count(*)::int` }).from(offerItemParticipants).where(where), query.limit, query.offset);
-    },
-    async getOfferItemParticipantById(db, id) {
-        const [row] = await db
-            .select()
-            .from(offerItemParticipants)
-            .where(eq(offerItemParticipants.id, id))
-            .limit(1);
-        return row ?? null;
-    },
-    async createOfferItemParticipant(db, data) {
-        const [row] = await db.insert(offerItemParticipants).values(data).returning();
-        return row ?? null;
-    },
-    async updateOfferItemParticipant(db, id, data) {
-        const [row] = await db
-            .update(offerItemParticipants)
-            .set(data)
-            .where(eq(offerItemParticipants.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOfferItemParticipant(db, id) {
-        const [row] = await db
-            .delete(offerItemParticipants)
-            .where(eq(offerItemParticipants.id, id))
-            .returning({ id: offerItemParticipants.id });
-        return row ?? null;
-    },
-    async listOrders(db, query) {
-        const conditions = [];
-        if (query.status)
-            conditions.push(eq(orders.status, query.status));
-        if (query.offerId)
-            conditions.push(eq(orders.offerId, query.offerId));
-        if (query.opportunityId)
-            conditions.push(eq(orders.opportunityId, query.opportunityId));
-        if (query.quoteId)
-            conditions.push(eq(orders.quoteId, query.quoteId));
-        if (query.personId)
-            conditions.push(eq(orders.personId, query.personId));
-        if (query.organizationId)
-            conditions.push(eq(orders.organizationId, query.organizationId));
-        if (query.marketId)
-            conditions.push(eq(orders.marketId, query.marketId));
-        if (query.search) {
-            const term = `%${query.search}%`;
-            conditions.push(or(ilike(orders.orderNumber, term), ilike(orders.title, term)));
-        }
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(orders)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(desc(orders.createdAt)), db.select({ count: sql `count(*)::int` }).from(orders).where(where), query.limit, query.offset);
-    },
-    async getOrderById(db, id) {
-        const [row] = await db.select().from(orders).where(eq(orders.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOrder(db, data) {
-        const { orderedAt, confirmedAt, cancelledAt, expiresAt, ...rest } = data;
-        const [row] = await db
-            .insert(orders)
-            .values({
-            ...rest,
-            orderedAt: normalizeTimestamp(orderedAt),
-            confirmedAt: normalizeTimestamp(confirmedAt),
-            cancelledAt: normalizeTimestamp(cancelledAt),
-            expiresAt: normalizeTimestamp(expiresAt),
-        })
-            .returning();
-        return row ?? null;
-    },
-    async updateOrder(db, id, data) {
-        const { orderedAt, confirmedAt, cancelledAt, expiresAt, ...rest } = data;
-        const [row] = await db
-            .update(orders)
-            .set({
-            ...rest,
-            orderedAt: normalizeTimestamp(orderedAt),
-            confirmedAt: normalizeTimestamp(confirmedAt),
-            cancelledAt: normalizeTimestamp(cancelledAt),
-            expiresAt: normalizeTimestamp(expiresAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(orders.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrder(db, id) {
-        const [row] = await db.delete(orders).where(eq(orders.id, id)).returning({ id: orders.id });
-        return row ?? null;
-    },
-    async listOrderParticipants(db, query) {
-        const conditions = [];
-        if (query.orderId)
-            conditions.push(eq(orderParticipants.orderId, query.orderId));
-        if (query.personId)
-            conditions.push(eq(orderParticipants.personId, query.personId));
-        const where = conditions.length ? and(...conditions) : undefined;
-        const rows = db
-            .select()
-            .from(orderParticipants)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(orderParticipants.createdAt))
-            .then((items) => items.map(toOrderParticipantResponse));
-        return paginate(rows, db.select({ count: sql `count(*)::int` }).from(orderParticipants).where(where), query.limit, query.offset);
-    },
-    async getOrderParticipantById(db, id) {
-        const [row] = await db
-            .select()
-            .from(orderParticipants)
-            .where(eq(orderParticipants.id, id))
-            .limit(1);
-        return row ? toOrderParticipantResponse(row) : null;
-    },
-    async createOrderParticipant(db, data) {
-        const { dateOfBirth, nationality, ...rest } = data;
-        void dateOfBirth;
-        void nationality;
-        const [row] = await db.insert(orderParticipants).values(rest).returning();
-        return row ? toOrderParticipantResponse(row) : null;
-    },
-    async updateOrderParticipant(db, id, data) {
-        const { dateOfBirth, nationality, ...rest } = data;
-        void dateOfBirth;
-        void nationality;
-        const [row] = await db
-            .update(orderParticipants)
-            .set({ ...rest, updatedAt: new Date() })
-            .where(eq(orderParticipants.id, id))
-            .returning();
-        return row ? toOrderParticipantResponse(row) : null;
-    },
-    async deleteOrderParticipant(db, id) {
-        const [row] = await db
-            .delete(orderParticipants)
-            .where(eq(orderParticipants.id, id))
-            .returning({ id: orderParticipants.id });
-        return row ?? null;
-    },
-    async listOrderItems(db, query) {
-        const conditions = [];
-        if (query.orderId)
-            conditions.push(eq(orderItems.orderId, query.orderId));
-        if (query.offerItemId)
-            conditions.push(eq(orderItems.offerItemId, query.offerItemId));
-        if (query.productId)
-            conditions.push(eq(orderItems.productId, query.productId));
-        if (query.optionId)
-            conditions.push(eq(orderItems.optionId, query.optionId));
-        if (query.unitId)
-            conditions.push(eq(orderItems.unitId, query.unitId));
-        if (query.slotId)
-            conditions.push(eq(orderItems.slotId, query.slotId));
-        if (query.status)
-            conditions.push(eq(orderItems.status, query.status));
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(orderItems)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(orderItems.createdAt)), db.select({ count: sql `count(*)::int` }).from(orderItems).where(where), query.limit, query.offset);
-    },
-    async getOrderItemById(db, id) {
-        const [row] = await db.select().from(orderItems).where(eq(orderItems.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOrderItem(db, data) {
-        const { startsAt, endsAt, ...rest } = data;
-        const [row] = await db
-            .insert(orderItems)
-            .values({
-            ...rest,
-            startsAt: normalizeTimestamp(startsAt),
-            endsAt: normalizeTimestamp(endsAt),
-        })
-            .returning();
-        return row ?? null;
-    },
-    async updateOrderItem(db, id, data) {
-        const { startsAt, endsAt, ...rest } = data;
-        const [row] = await db
-            .update(orderItems)
-            .set({
-            ...rest,
-            startsAt: normalizeTimestamp(startsAt),
-            endsAt: normalizeTimestamp(endsAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(orderItems.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrderItem(db, id) {
-        const [row] = await db
-            .delete(orderItems)
-            .where(eq(orderItems.id, id))
-            .returning({ id: orderItems.id });
-        return row ?? null;
-    },
-    async listOrderItemParticipants(db, query) {
-        const conditions = [];
-        if (query.orderItemId)
-            conditions.push(eq(orderItemParticipants.orderItemId, query.orderItemId));
-        if (query.participantId)
-            conditions.push(eq(orderItemParticipants.participantId, query.participantId));
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(orderItemParticipants)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(orderItemParticipants.createdAt)), db.select({ count: sql `count(*)::int` }).from(orderItemParticipants).where(where), query.limit, query.offset);
-    },
-    async getOrderItemParticipantById(db, id) {
-        const [row] = await db
-            .select()
-            .from(orderItemParticipants)
-            .where(eq(orderItemParticipants.id, id))
-            .limit(1);
-        return row ?? null;
-    },
-    async createOrderItemParticipant(db, data) {
-        const [row] = await db.insert(orderItemParticipants).values(data).returning();
-        return row ?? null;
-    },
-    async updateOrderItemParticipant(db, id, data) {
-        const [row] = await db
-            .update(orderItemParticipants)
-            .set(data)
-            .where(eq(orderItemParticipants.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrderItemParticipant(db, id) {
-        const [row] = await db
-            .delete(orderItemParticipants)
-            .where(eq(orderItemParticipants.id, id))
-            .returning({ id: orderItemParticipants.id });
-        return row ?? null;
-    },
-    async listOrderTerms(db, query) {
-        const conditions = [];
-        if (query.offerId)
-            conditions.push(eq(orderTerms.offerId, query.offerId));
-        if (query.orderId)
-            conditions.push(eq(orderTerms.orderId, query.orderId));
-        if (query.termType)
-            conditions.push(eq(orderTerms.termType, query.termType));
-        if (query.acceptanceStatus)
-            conditions.push(eq(orderTerms.acceptanceStatus, query.acceptanceStatus));
-        const where = conditions.length ? and(...conditions) : undefined;
-        return paginate(db
-            .select()
-            .from(orderTerms)
-            .where(where)
-            .limit(query.limit)
-            .offset(query.offset)
-            .orderBy(asc(orderTerms.sortOrder), asc(orderTerms.createdAt)), db.select({ count: sql `count(*)::int` }).from(orderTerms).where(where), query.limit, query.offset);
-    },
-    async getOrderTermById(db, id) {
-        const [row] = await db.select().from(orderTerms).where(eq(orderTerms.id, id)).limit(1);
-        return row ?? null;
-    },
-    async createOrderTerm(db, data) {
-        const { acceptedAt, ...rest } = data;
-        const [row] = await db
-            .insert(orderTerms)
-            .values({
-            ...rest,
-            acceptedAt: normalizeTimestamp(acceptedAt),
-        })
-            .returning();
-        return row ?? null;
-    },
-    async updateOrderTerm(db, id, data) {
-        const { acceptedAt, ...rest } = data;
-        const [row] = await db
-            .update(orderTerms)
-            .set({
-            ...rest,
-            acceptedAt: normalizeTimestamp(acceptedAt),
-            updatedAt: new Date(),
-        })
-            .where(eq(orderTerms.id, id))
-            .returning();
-        return row ?? null;
-    },
-    async deleteOrderTerm(db, id) {
-        const [row] = await db
-            .delete(orderTerms)
-            .where(eq(orderTerms.id, id))
-            .returning({ id: orderTerms.id });
-        return row ?? null;
-    },
+    listOffers,
+    getOfferById,
+    createOffer,
+    createOfferBundle,
+    updateOffer,
+    deleteOffer,
+    listOfferParticipants,
+    getOfferParticipantById,
+    createOfferParticipant,
+    updateOfferParticipant,
+    deleteOfferParticipant,
+    listOfferItems,
+    getOfferItemById,
+    createOfferItem,
+    updateOfferItem,
+    deleteOfferItem,
+    listOfferItemParticipants,
+    getOfferItemParticipantById,
+    createOfferItemParticipant,
+    updateOfferItemParticipant,
+    deleteOfferItemParticipant,
+    listOrders,
+    getOrderById,
+    createOrder,
+    updateOrder,
+    deleteOrder,
+    listOrderParticipants,
+    getOrderParticipantById,
+    createOrderParticipant,
+    updateOrderParticipant,
+    deleteOrderParticipant,
+    listOrderItems,
+    getOrderItemById,
+    createOrderItem,
+    updateOrderItem,
+    deleteOrderItem,
+    listOrderItemParticipants,
+    getOrderItemParticipantById,
+    createOrderItemParticipant,
+    updateOrderItemParticipant,
+    deleteOrderItemParticipant,
+    listOrderTerms,
+    getOrderTermById,
+    createOrderTerm,
+    updateOrderTerm,
+    deleteOrderTerm,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/transactions",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "exports": {
@@ -29,10 +29,10 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/db": "0.1.1",
-    "@voyantjs/hono": "0.1.1",
-    "@voyantjs/core": "0.1.1",
-    "@voyantjs/utils": "0.1.1"
+    "@voyantjs/core": "0.3.0",
+    "@voyantjs/db": "0.3.0",
+    "@voyantjs/hono": "0.3.0",
+    "@voyantjs/utils": "0.3.0"
   },
   "devDependencies": {
     "typescript": "^6.0.2",