@porulle/plugin-uom 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# @porulle/plugin-uom
+
+Units of measure, conversions between units, and per-entity UOM assignments for catalog and operations.
+
+## Install
+
+```bash
+bun add @porulle/plugin-uom
+```
+
+Add to `commerce.config.ts`:
+
+```typescript
+import { uomPlugin } from "@porulle/plugin-uom";
+
+export default defineConfig({
+  plugins: [uomPlugin()],
+});
+```
+
+Add to `drizzle.config.ts`:
+
+```typescript
+schema: [
+  "./node_modules/@porulle/plugin-uom/src/schema.ts",
+  // ...
+],
+```
+
+## What it does
+
+Maintains a canonical unit list, directed conversion factors, optional per-entity stocking/selling units, and a convert helper for quantity translation across the graph.
+
+## Routes exposed
+
+**`/uom`** — `POST/GET /units`, `POST/GET /conversions`, `POST /convert`, `POST/GET /entities/{id}/uom`
+
+## Hooks
+
+**Emitted:** none.
+
+**Consumed:** none.
+
+## MCP tools
+
+None.
+
+## Configuration options
+
+None (`uomPlugin()` takes no options).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { Db } from "./types.js";
+export { UOMService } from "./services/uom-service.js";
+export declare function uomPlugin(): import("@porulle/core").CommercePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,YAAY,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD,wBAAgB,SAAS,2CAgBxB"}

package/dist/index.js

@@ -0,0 +1,23 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { unitsOfMeasure, uomConversions, entityUom } from "./schema.js";
+import { UOMService } from "./services/uom-service.js";
+import { buildUOMRoutes } from "./routes/uom.js";
+export { UOMService } from "./services/uom-service.js";
+export function uomPlugin() {
+    return defineCommercePlugin({
+        id: "uom",
+        version: "1.0.0",
+        permissions: [
+            { scope: "uom:admin", description: "Create/edit units, conversions, entity UOM assignments." },
+            { scope: "uom:read", description: "View units, conversions, convert quantities." },
+        ],
+        schema: () => ({ unitsOfMeasure, uomConversions, entityUom }),
+        hooks: () => [],
+        routes: (ctx) => {
+            const db = ctx.database.db;
+            if (!db)
+                return [];
+            return buildUOMRoutes(new UOMService(db), ctx);
+        },
+    });
+}

package/dist/routes/uom.d.ts

@@ -0,0 +1,9 @@
+import type { UOMService } from "../services/uom-service.js";
+import type { PluginRouteRegistration } from "@porulle/core";
+export declare function buildUOMRoutes(service: UOMService, ctx: {
+    services?: Record<string, unknown>;
+    database?: {
+        db: unknown;
+    };
+}): PluginRouteRegistration[];
+//# sourceMappingURL=uom.d.ts.map

package/dist/routes/uom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uom.d.ts","sourceRoot":"","sources":["../../src/routes/uom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EACnB,GAAG,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,GACtE,uBAAuB,EAAE,CA+D3B"}

package/dist/routes/uom.js

@@ -0,0 +1,65 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+export function buildUOMRoutes(service, ctx) {
+    const r = router("Units of Measure", "/uom", ctx);
+    r.post("/units").summary("Create unit").permission("uom:admin")
+        .input(z.object({ code: z.string().min(1).max(20), name: z.string().min(1), category: z.enum(["weight", "volume", "length", "count", "area", "time"]), isBaseUnit: z.boolean().optional() }))
+        .handler(async ({ input, orgId }) => {
+        const body = input;
+        const result = await service.createUnit(orgId, body);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.get("/units").summary("List units").permission("uom:read")
+        .query(z.object({ category: z.enum(["weight", "volume", "length", "count", "area", "time"]).optional() }))
+        .handler(async ({ query, orgId }) => {
+        const q = query;
+        const result = await service.listUnits(orgId, q.category);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.post("/conversions").summary("Create conversion").permission("uom:admin")
+        .input(z.object({ fromUnitId: z.string().uuid(), toUnitId: z.string().uuid(), factor: z.number().int().positive() }))
+        .handler(async ({ input, orgId }) => {
+        const body = input;
+        const result = await service.createConversion(orgId, body);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.get("/conversions").summary("List conversions").permission("uom:read")
+        .handler(async ({ orgId }) => {
+        const result = await service.listConversions(orgId);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.post("/convert").summary("Convert quantity").permission("uom:read")
+        .input(z.object({ fromUnitId: z.string().uuid(), toUnitId: z.string().uuid(), quantity: z.number().positive() }))
+        .handler(async ({ input, orgId }) => {
+        const body = input;
+        const result = await service.convert(orgId, body);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.post("/entities/{id}/uom").summary("Set entity UOM").permission("uom:admin")
+        .input(z.object({ purchaseUomId: z.string().uuid(), stockUomId: z.string().uuid(), saleUomId: z.string().uuid(), yieldPercentage: z.number().int().min(1).max(100).optional() }))
+        .handler(async ({ params, input, orgId }) => {
+        const body = input;
+        const result = await service.setEntityUom(orgId, { entityId: params.id, ...body });
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    r.get("/entities/{id}/uom").summary("Get entity UOM").permission("uom:read")
+        .handler(async ({ params, orgId }) => {
+        const result = await service.getEntityUom(orgId, params.id);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.value;
+    });
+    return r.routes();
+}

package/dist/schema.d.ts

@@ -0,0 +1,413 @@
+export declare const unitsOfMeasure: import("drizzle-orm/pg-core/table").PgTableWithColumns<{
+    name: "units_of_measure";
+    schema: undefined;
+    columns: {
+        id: import("@porulle/core/drizzle").PgColumn<{
+            name: "id";
+            tableName: "units_of_measure";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("@porulle/core/drizzle").PgColumn<{
+            name: "organization_id";
+            tableName: "units_of_measure";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        code: import("@porulle/core/drizzle").PgColumn<{
+            name: "code";
+            tableName: "units_of_measure";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("@porulle/core/drizzle").PgColumn<{
+            name: "name";
+            tableName: "units_of_measure";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        category: import("@porulle/core/drizzle").PgColumn<{
+            name: "category";
+            tableName: "units_of_measure";
+            dataType: "string";
+            columnType: "PgText";
+            data: "length" | "weight" | "volume" | "count" | "area" | "time";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["weight", "volume", "length", "count", "area", "time"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isBaseUnit: import("@porulle/core/drizzle").PgColumn<{
+            name: "is_base_unit";
+            tableName: "units_of_measure";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "created_at";
+            tableName: "units_of_measure";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "updated_at";
+            tableName: "units_of_measure";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const uomConversions: import("drizzle-orm/pg-core/table").PgTableWithColumns<{
+    name: "uom_conversions";
+    schema: undefined;
+    columns: {
+        id: import("@porulle/core/drizzle").PgColumn<{
+            name: "id";
+            tableName: "uom_conversions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("@porulle/core/drizzle").PgColumn<{
+            name: "organization_id";
+            tableName: "uom_conversions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromUnitId: import("@porulle/core/drizzle").PgColumn<{
+            name: "from_unit_id";
+            tableName: "uom_conversions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toUnitId: import("@porulle/core/drizzle").PgColumn<{
+            name: "to_unit_id";
+            tableName: "uom_conversions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        factor: import("@porulle/core/drizzle").PgColumn<{
+            name: "factor";
+            tableName: "uom_conversions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "created_at";
+            tableName: "uom_conversions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const entityUom: import("drizzle-orm/pg-core/table").PgTableWithColumns<{
+    name: "entity_uom";
+    schema: undefined;
+    columns: {
+        id: import("@porulle/core/drizzle").PgColumn<{
+            name: "id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("@porulle/core/drizzle").PgColumn<{
+            name: "organization_id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityId: import("@porulle/core/drizzle").PgColumn<{
+            name: "entity_id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        purchaseUomId: import("@porulle/core/drizzle").PgColumn<{
+            name: "purchase_uom_id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stockUomId: import("@porulle/core/drizzle").PgColumn<{
+            name: "stock_uom_id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        saleUomId: import("@porulle/core/drizzle").PgColumn<{
+            name: "sale_uom_id";
+            tableName: "entity_uom";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        yieldPercentage: import("@porulle/core/drizzle").PgColumn<{
+            name: "yield_percentage";
+            tableName: "entity_uom";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "created_at";
+            tableName: "entity_uom";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("@porulle/core/drizzle").PgColumn<{
+            name: "updated_at";
+            tableName: "entity_uom";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYxB,CAAC;AAEJ,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxB,CAAC;AAEJ,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnB,CAAC"}

package/dist/schema.js

@@ -0,0 +1,37 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, index, uniqueIndex } from "@porulle/core/drizzle";
+export const unitsOfMeasure = pgTable("units_of_measure", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    code: text("code").notNull(),
+    name: text("name").notNull(),
+    category: text("category", { enum: ["weight", "volume", "length", "count", "area", "time"] }).notNull(),
+    isBaseUnit: boolean("is_base_unit").notNull().default(false),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_uom_org").on(table.organizationId),
+    codeUnique: uniqueIndex("uom_org_code_unique").on(table.organizationId, table.code),
+}));
+export const uomConversions = pgTable("uom_conversions", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    fromUnitId: uuid("from_unit_id").references(() => unitsOfMeasure.id, { onDelete: "cascade" }).notNull(),
+    toUnitId: uuid("to_unit_id").references(() => unitsOfMeasure.id, { onDelete: "cascade" }).notNull(),
+    factor: integer("factor").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    orgIdx: index("idx_uom_conversions_org").on(table.organizationId),
+}));
+export const entityUom = pgTable("entity_uom", {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    entityId: uuid("entity_id").notNull(),
+    purchaseUomId: uuid("purchase_uom_id").references(() => unitsOfMeasure.id).notNull(),
+    stockUomId: uuid("stock_uom_id").references(() => unitsOfMeasure.id).notNull(),
+    saleUomId: uuid("sale_uom_id").references(() => unitsOfMeasure.id).notNull(),
+    yieldPercentage: integer("yield_percentage").notNull().default(100),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    entityUnique: uniqueIndex("entity_uom_org_entity_unique").on(table.organizationId, table.entityId),
+}));

package/dist/services/uom-service.d.ts

@@ -0,0 +1,40 @@
+import type { PluginResult } from "@porulle/core";
+import type { Db, UnitOfMeasure, UOMConversion, EntityUOM, UOMCategory } from "../types.js";
+export declare class UOMService {
+    private db;
+    constructor(db: Db);
+    createUnit(orgId: string, input: {
+        code: string;
+        name: string;
+        category: UOMCategory;
+        isBaseUnit?: boolean;
+    }): Promise<PluginResult<UnitOfMeasure>>;
+    listUnits(orgId: string, category?: UOMCategory): Promise<PluginResult<UnitOfMeasure[]>>;
+    createConversion(orgId: string, input: {
+        fromUnitId: string;
+        toUnitId: string;
+        factor: number;
+    }): Promise<PluginResult<UOMConversion>>;
+    listConversions(orgId: string): Promise<PluginResult<UOMConversion[]>>;
+    convert(orgId: string, input: {
+        fromUnitId: string;
+        toUnitId: string;
+        quantity: number;
+    }): Promise<PluginResult<{
+        result: number;
+        fromCode: string;
+        toCode: string;
+    }>>;
+    setEntityUom(orgId: string, input: {
+        entityId: string;
+        purchaseUomId: string;
+        stockUomId: string;
+        saleUomId: string;
+        yieldPercentage?: number;
+    }): Promise<PluginResult<EntityUOM>>;
+    getEntityUom(orgId: string, entityId: string): Promise<PluginResult<EntityUOM>>;
+    calculateYield(yieldPercentage: number, requiredQuantity: number): Promise<PluginResult<{
+        purchaseQuantity: number;
+    }>>;
+}
+//# sourceMappingURL=uom-service.d.ts.map

package/dist/services/uom-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uom-service.d.ts","sourceRoot":"","sources":["../../src/services/uom-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAE,EAAE,EAAE,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE5F,qBAAa,UAAU;IACT,OAAO,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEpB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACrC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;KACzE,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IAWlC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;IAOxF,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QAC3C,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;KACtD,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IASlC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,CAAC;IAMtE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QAClC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;KACxD,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IA+BzE,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;QACvC,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1G,GAAG,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAkB9B,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAO/E,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAAE,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAI7H"}

package/dist/services/uom-service.js

@@ -0,0 +1,91 @@
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import { unitsOfMeasure, uomConversions, entityUom } from "../schema.js";
+export class UOMService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createUnit(orgId, input) {
+        const existing = await this.db.select().from(unitsOfMeasure)
+            .where(and(eq(unitsOfMeasure.organizationId, orgId), eq(unitsOfMeasure.code, input.code)));
+        if (existing.length > 0)
+            return Err(`Unit '${input.code}' already exists`);
+        const rows = await this.db.insert(unitsOfMeasure).values({
+            organizationId: orgId, code: input.code, name: input.name,
+            category: input.category, isBaseUnit: input.isBaseUnit ?? false,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async listUnits(orgId, category) {
+        const conditions = [eq(unitsOfMeasure.organizationId, orgId)];
+        if (category)
+            conditions.push(eq(unitsOfMeasure.category, category));
+        const rows = await this.db.select().from(unitsOfMeasure).where(and(...conditions));
+        return Ok(rows);
+    }
+    async createConversion(orgId, input) {
+        if (input.factor <= 0)
+            return Err("Factor must be positive");
+        const rows = await this.db.insert(uomConversions).values({
+            organizationId: orgId, fromUnitId: input.fromUnitId,
+            toUnitId: input.toUnitId, factor: input.factor,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async listConversions(orgId) {
+        const rows = await this.db.select().from(uomConversions)
+            .where(eq(uomConversions.organizationId, orgId));
+        return Ok(rows);
+    }
+    async convert(orgId, input) {
+        if (input.fromUnitId === input.toUnitId) {
+            const unit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.fromUnitId));
+            return Ok({ result: input.quantity, fromCode: unit[0]?.code ?? "", toCode: unit[0]?.code ?? "" });
+        }
+        // Try forward conversion
+        const forward = await this.db.select().from(uomConversions).where(and(eq(uomConversions.organizationId, orgId), eq(uomConversions.fromUnitId, input.fromUnitId), eq(uomConversions.toUnitId, input.toUnitId)));
+        const fromUnit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.fromUnitId));
+        const toUnit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.toUnitId));
+        const fromCode = fromUnit[0]?.code ?? "";
+        const toCode = toUnit[0]?.code ?? "";
+        if (forward.length > 0) {
+            return Ok({ result: Math.round(input.quantity * forward[0].factor / 10000), fromCode, toCode });
+        }
+        // Try reverse
+        const reverse = await this.db.select().from(uomConversions).where(and(eq(uomConversions.organizationId, orgId), eq(uomConversions.fromUnitId, input.toUnitId), eq(uomConversions.toUnitId, input.fromUnitId)));
+        if (reverse.length > 0) {
+            return Ok({ result: Math.round(input.quantity * 10000 / reverse[0].factor), fromCode, toCode });
+        }
+        return Err(`No conversion found between '${fromCode}' and '${toCode}'`);
+    }
+    async setEntityUom(orgId, input) {
+        const existing = await this.db.select().from(entityUom)
+            .where(and(eq(entityUom.organizationId, orgId), eq(entityUom.entityId, input.entityId)));
+        if (existing.length > 0) {
+            const rows = await this.db.update(entityUom).set({
+                purchaseUomId: input.purchaseUomId, stockUomId: input.stockUomId,
+                saleUomId: input.saleUomId, yieldPercentage: input.yieldPercentage ?? 100, updatedAt: new Date(),
+            }).where(eq(entityUom.id, existing[0].id)).returning();
+            return Ok(rows[0]);
+        }
+        const rows = await this.db.insert(entityUom).values({
+            organizationId: orgId, entityId: input.entityId,
+            purchaseUomId: input.purchaseUomId, stockUomId: input.stockUomId,
+            saleUomId: input.saleUomId, yieldPercentage: input.yieldPercentage ?? 100,
+        }).returning();
+        return Ok(rows[0]);
+    }
+    async getEntityUom(orgId, entityId) {
+        const rows = await this.db.select().from(entityUom)
+            .where(and(eq(entityUom.organizationId, orgId), eq(entityUom.entityId, entityId)));
+        if (rows.length === 0)
+            return Err("No UOM assignment for this entity");
+        return Ok(rows[0]);
+    }
+    async calculateYield(yieldPercentage, requiredQuantity) {
+        if (yieldPercentage <= 0 || yieldPercentage > 100)
+            return Ok({ purchaseQuantity: requiredQuantity });
+        return Ok({ purchaseQuantity: Math.ceil(requiredQuantity * 100 / yieldPercentage) });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type { PluginDb as Db } from "@porulle/core";
+import type { unitsOfMeasure, uomConversions, entityUom } from "./schema.js";
+export type UnitOfMeasure = typeof unitsOfMeasure.$inferSelect;
+export type UOMConversion = typeof uomConversions.$inferSelect;
+export type EntityUOM = typeof entityUom.$inferSelect;
+export type UOMCategory = "weight" | "volume" | "length" | "count" | "area" | "time";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7E,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAC/D,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@porulle/plugin-uom",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    },
+    "./schema": {
+      "bun": "./src/schema.ts",
+      "import": "./dist/schema.js",
+      "require": "./dist/schema.js",
+      "types": "./src/schema.ts"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist tsconfig.build.tsbuildinfo && tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@porulle/core": "workspace:*",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^24.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ],
+  "description": "Units of measure, conversions between units, and per-entity UOM assignments for catalog and operations.",
+  "homepage": "https://porulle-docs.vercel.app",
+  "bugs": {
+    "url": "https://github.com/asyncdotengineering/porulle/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asyncdotengineering/porulle.git",
+    "directory": "packages/plugins/plugin-uom"
+  },
+  "author": "Porulle contributors"
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { unitsOfMeasure, uomConversions, entityUom } from "./schema.js";
+import { UOMService } from "./services/uom-service.js";
+import { buildUOMRoutes } from "./routes/uom.js";
+import type { Db } from "./types.js";
+
+export type { Db } from "./types.js";
+export { UOMService } from "./services/uom-service.js";
+
+export function uomPlugin() {
+  return defineCommercePlugin({
+    id: "uom",
+    version: "1.0.0",
+    permissions: [
+      { scope: "uom:admin", description: "Create/edit units, conversions, entity UOM assignments." },
+      { scope: "uom:read", description: "View units, conversions, convert quantities." },
+    ],
+    schema: () => ({ unitsOfMeasure, uomConversions, entityUom }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db;
+      if (!db) return [];
+      return buildUOMRoutes(new UOMService(db), ctx);
+    },
+  });
+}

package/src/routes/uom.ts

@@ -0,0 +1,72 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+import type { UOMService } from "../services/uom-service.js";
+import type { PluginRouteRegistration } from "@porulle/core";
+
+export function buildUOMRoutes(
+  service: UOMService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Units of Measure", "/uom", ctx);
+
+  r.post("/units").summary("Create unit").permission("uom:admin")
+    .input(z.object({ code: z.string().min(1).max(20), name: z.string().min(1), category: z.enum(["weight", "volume", "length", "count", "area", "time"]), isBaseUnit: z.boolean().optional() }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { code: string; name: string; category: "weight" | "volume" | "length" | "count" | "area" | "time"; isBaseUnit?: boolean };
+      const result = await service.createUnit(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/units").summary("List units").permission("uom:read")
+    .query(z.object({ category: z.enum(["weight", "volume", "length", "count", "area", "time"]).optional() }))
+    .handler(async ({ query, orgId }) => {
+      const q = query as { category?: "weight" | "volume" | "length" | "count" | "area" | "time" };
+      const result = await service.listUnits(orgId, q.category);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/conversions").summary("Create conversion").permission("uom:admin")
+    .input(z.object({ fromUnitId: z.string().uuid(), toUnitId: z.string().uuid(), factor: z.number().int().positive() }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { fromUnitId: string; toUnitId: string; factor: number };
+      const result = await service.createConversion(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/conversions").summary("List conversions").permission("uom:read")
+    .handler(async ({ orgId }) => {
+      const result = await service.listConversions(orgId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/convert").summary("Convert quantity").permission("uom:read")
+    .input(z.object({ fromUnitId: z.string().uuid(), toUnitId: z.string().uuid(), quantity: z.number().positive() }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as { fromUnitId: string; toUnitId: string; quantity: number };
+      const result = await service.convert(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/entities/{id}/uom").summary("Set entity UOM").permission("uom:admin")
+    .input(z.object({ purchaseUomId: z.string().uuid(), stockUomId: z.string().uuid(), saleUomId: z.string().uuid(), yieldPercentage: z.number().int().min(1).max(100).optional() }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { purchaseUomId: string; stockUomId: string; saleUomId: string; yieldPercentage?: number };
+      const result = await service.setEntityUom(orgId, { entityId: params.id!, ...body });
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/entities/{id}/uom").summary("Get entity UOM").permission("uom:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getEntityUom(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,40 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, index, uniqueIndex } from "@porulle/core/drizzle";
+
+export const unitsOfMeasure = pgTable("units_of_measure", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  code: text("code").notNull(),
+  name: text("name").notNull(),
+  category: text("category", { enum: ["weight", "volume", "length", "count", "area", "time"] }).notNull(),
+  isBaseUnit: boolean("is_base_unit").notNull().default(false),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_uom_org").on(table.organizationId),
+  codeUnique: uniqueIndex("uom_org_code_unique").on(table.organizationId, table.code),
+}));
+
+export const uomConversions = pgTable("uom_conversions", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  fromUnitId: uuid("from_unit_id").references(() => unitsOfMeasure.id, { onDelete: "cascade" }).notNull(),
+  toUnitId: uuid("to_unit_id").references(() => unitsOfMeasure.id, { onDelete: "cascade" }).notNull(),
+  factor: integer("factor").notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_uom_conversions_org").on(table.organizationId),
+}));
+
+export const entityUom = pgTable("entity_uom", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  entityId: uuid("entity_id").notNull(),
+  purchaseUomId: uuid("purchase_uom_id").references(() => unitsOfMeasure.id).notNull(),
+  stockUomId: uuid("stock_uom_id").references(() => unitsOfMeasure.id).notNull(),
+  saleUomId: uuid("sale_uom_id").references(() => unitsOfMeasure.id).notNull(),
+  yieldPercentage: integer("yield_percentage").notNull().default(100),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  entityUnique: uniqueIndex("entity_uom_org_entity_unique").on(table.organizationId, table.entityId),
+}));

package/src/services/uom-service.ts

@@ -0,0 +1,111 @@
+import { eq, and } from "@porulle/core/drizzle";
+import { Ok, Err } from "@porulle/core";
+import type { PluginResult } from "@porulle/core";
+import { unitsOfMeasure, uomConversions, entityUom } from "../schema.js";
+import type { Db, UnitOfMeasure, UOMConversion, EntityUOM, UOMCategory } from "../types.js";
+
+export class UOMService {
+  constructor(private db: Db) {}
+
+  async createUnit(orgId: string, input: {
+    code: string; name: string; category: UOMCategory; isBaseUnit?: boolean;
+  }): Promise<PluginResult<UnitOfMeasure>> {
+    const existing = await this.db.select().from(unitsOfMeasure)
+      .where(and(eq(unitsOfMeasure.organizationId, orgId), eq(unitsOfMeasure.code, input.code)));
+    if (existing.length > 0) return Err(`Unit '${input.code}' already exists`);
+    const rows = await this.db.insert(unitsOfMeasure).values({
+      organizationId: orgId, code: input.code, name: input.name,
+      category: input.category, isBaseUnit: input.isBaseUnit ?? false,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async listUnits(orgId: string, category?: UOMCategory): Promise<PluginResult<UnitOfMeasure[]>> {
+    const conditions = [eq(unitsOfMeasure.organizationId, orgId)];
+    if (category) conditions.push(eq(unitsOfMeasure.category, category));
+    const rows = await this.db.select().from(unitsOfMeasure).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async createConversion(orgId: string, input: {
+    fromUnitId: string; toUnitId: string; factor: number;
+  }): Promise<PluginResult<UOMConversion>> {
+    if (input.factor <= 0) return Err("Factor must be positive");
+    const rows = await this.db.insert(uomConversions).values({
+      organizationId: orgId, fromUnitId: input.fromUnitId,
+      toUnitId: input.toUnitId, factor: input.factor,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async listConversions(orgId: string): Promise<PluginResult<UOMConversion[]>> {
+    const rows = await this.db.select().from(uomConversions)
+      .where(eq(uomConversions.organizationId, orgId));
+    return Ok(rows);
+  }
+
+  async convert(orgId: string, input: {
+    fromUnitId: string; toUnitId: string; quantity: number;
+  }): Promise<PluginResult<{ result: number; fromCode: string; toCode: string }>> {
+    if (input.fromUnitId === input.toUnitId) {
+      const unit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.fromUnitId));
+      return Ok({ result: input.quantity, fromCode: unit[0]?.code ?? "", toCode: unit[0]?.code ?? "" });
+    }
+    // Try forward conversion
+    const forward = await this.db.select().from(uomConversions).where(and(
+      eq(uomConversions.organizationId, orgId),
+      eq(uomConversions.fromUnitId, input.fromUnitId),
+      eq(uomConversions.toUnitId, input.toUnitId),
+    ));
+    const fromUnit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.fromUnitId));
+    const toUnit = await this.db.select().from(unitsOfMeasure).where(eq(unitsOfMeasure.id, input.toUnitId));
+    const fromCode = fromUnit[0]?.code ?? "";
+    const toCode = toUnit[0]?.code ?? "";
+
+    if (forward.length > 0) {
+      return Ok({ result: Math.round(input.quantity * forward[0]!.factor / 10000), fromCode, toCode });
+    }
+    // Try reverse
+    const reverse = await this.db.select().from(uomConversions).where(and(
+      eq(uomConversions.organizationId, orgId),
+      eq(uomConversions.fromUnitId, input.toUnitId),
+      eq(uomConversions.toUnitId, input.fromUnitId),
+    ));
+    if (reverse.length > 0) {
+      return Ok({ result: Math.round(input.quantity * 10000 / reverse[0]!.factor), fromCode, toCode });
+    }
+    return Err(`No conversion found between '${fromCode}' and '${toCode}'`);
+  }
+
+  async setEntityUom(orgId: string, input: {
+    entityId: string; purchaseUomId: string; stockUomId: string; saleUomId: string; yieldPercentage?: number;
+  }): Promise<PluginResult<EntityUOM>> {
+    const existing = await this.db.select().from(entityUom)
+      .where(and(eq(entityUom.organizationId, orgId), eq(entityUom.entityId, input.entityId)));
+    if (existing.length > 0) {
+      const rows = await this.db.update(entityUom).set({
+        purchaseUomId: input.purchaseUomId, stockUomId: input.stockUomId,
+        saleUomId: input.saleUomId, yieldPercentage: input.yieldPercentage ?? 100, updatedAt: new Date(),
+      }).where(eq(entityUom.id, existing[0]!.id)).returning();
+      return Ok(rows[0]!);
+    }
+    const rows = await this.db.insert(entityUom).values({
+      organizationId: orgId, entityId: input.entityId,
+      purchaseUomId: input.purchaseUomId, stockUomId: input.stockUomId,
+      saleUomId: input.saleUomId, yieldPercentage: input.yieldPercentage ?? 100,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async getEntityUom(orgId: string, entityId: string): Promise<PluginResult<EntityUOM>> {
+    const rows = await this.db.select().from(entityUom)
+      .where(and(eq(entityUom.organizationId, orgId), eq(entityUom.entityId, entityId)));
+    if (rows.length === 0) return Err("No UOM assignment for this entity");
+    return Ok(rows[0]!);
+  }
+
+  async calculateYield(yieldPercentage: number, requiredQuantity: number): Promise<PluginResult<{ purchaseQuantity: number }>> {
+    if (yieldPercentage <= 0 || yieldPercentage > 100) return Ok({ purchaseQuantity: requiredQuantity });
+    return Ok({ purchaseQuantity: Math.ceil(requiredQuantity * 100 / yieldPercentage) });
+  }
+}

package/src/types.ts

@@ -0,0 +1,6 @@
+export type { PluginDb as Db } from "@porulle/core";
+import type { unitsOfMeasure, uomConversions, entityUom } from "./schema.js";
+export type UnitOfMeasure = typeof unitsOfMeasure.$inferSelect;
+export type UOMConversion = typeof uomConversions.$inferSelect;
+export type EntityUOM = typeof entityUom.$inferSelect;
+export type UOMCategory = "weight" | "volume" | "length" | "count" | "area" | "time";