@managemint-solutions/sdk 0.65.0 → 0.67.0

package/dist/inventory/locations.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryLocationsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const LOCATION_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED},
+        name,
+        kind,
+        address,
+        latitude,
+        longitude,
+        is_default,
+        archived,
+        archived_at,
+        archived_by:user_profiles!archived_by ${transforms_1.USER_PROFILE_EMBED},
+        unarchived_at,
+        unarchived_by:user_profiles!unarchived_by ${transforms_1.USER_PROFILE_EMBED}
+      `;
+/** `latitude` and `longitude` are numeric columns, which PostgREST sends as strings. */
+const asLocation = (raw) => {
+    const row = raw;
+    return {
+        ...row,
+        latitude: row.latitude === null ? null : Number(row.latitude),
+        longitude: row.longitude === null ? null : Number(row.longitude),
+    };
+};
+/**
+ * Where stock is kept. A handful of rows per organization, read whole (no paging). One of them
+ * is the default: `is_default` moves between rows and is never cleared, so an organization
+ * with any location has one (the api stars the first location added; nothing is seeded).
+ */
+class InventoryLocationsResource {
+    supabase;
+    auth;
+    table;
+    audit;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_locations',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_LOCATIONS,
+        });
+        this.audit = new audit_1.EntityAuditTrail(supabase, auth, enum_1.AuditTrailEntityType.INVENTORY_LOCATIONS);
+    }
+    /** The organization's locations, the default first, then by name. */
+    async list(archive) {
+        const { data, error } = await this.supabase
+            .from('inventory_locations')
+            .select(LOCATION_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('archived', archive)
+            .order('is_default', { ascending: false })
+            .order('name');
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).map(asLocation);
+    }
+    async getById(locationId) {
+        const { data, error } = await this.supabase
+            .from('inventory_locations')
+            .select(LOCATION_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('mms_id', locationId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return asLocation(data);
+    }
+    /** The default location's id; null while the organization has no location yet. */
+    async defaultId() {
+        const { data, error } = await this.supabase
+            .from('inventory_locations')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('is_default', true)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data?.mms_id ?? null;
+    }
+    async create(input) {
+        if (input.is_default)
+            await this.clearDefault();
+        const row = await this.table.insert({
+            name: input.name,
+            kind: input.kind,
+            address: input.address ?? '',
+            latitude: input.latitude ?? null,
+            longitude: input.longitude ?? null,
+            is_default: input.is_default === true,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    async update(locationId, input) {
+        // The star moves; it is never taken away. Making another location the default clears this one.
+        if (input.is_default === false) {
+            const current = await this.getById(locationId);
+            if (current.is_default) {
+                throw new errors_1.SupabaseClientError({
+                    status: 400,
+                    error: 'Database Error',
+                    message: 'Make another location the default first',
+                });
+            }
+        }
+        if (input.is_default)
+            await this.clearDefault(locationId);
+        await this.table.update(locationId, {
+            name: input.name,
+            kind: input.kind,
+            address: input.address ?? '',
+            latitude: input.latitude ?? null,
+            longitude: input.longitude ?? null,
+            ...(input.is_default !== undefined && { is_default: input.is_default }),
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(locationId);
+    }
+    async archive(locationId) {
+        await this.table.transition(locationId, enum_1.AuditTrailAction.ARCHIVE, (0, transforms_1.archivedPatch)(this.auth.mms_id));
+        return this.getById(locationId);
+    }
+    async unarchive(locationId) {
+        await this.table.transition(locationId, enum_1.AuditTrailAction.UNARCHIVE, (0, transforms_1.unarchivedPatch)(this.auth.mms_id));
+        return this.getById(locationId);
+    }
+    /** Hard delete. The levels' and transfers' `on delete restrict` keys refuse a location still in use (23503 -> 409). */
+    async remove(locationId) {
+        await this.table.remove(locationId);
+    }
+    /** Takes the star off the current default (other than `except`), so the unique index lets the next one have it. */
+    async clearDefault(except) {
+        let query = this.supabase
+            .from('inventory_locations')
+            .update({ is_default: false })
+            .eq('organization_id', this.auth.organization_id)
+            .eq('is_default', true);
+        if (except)
+            query = query.neq('mms_id', except);
+        const { error } = await query;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+    }
+}
+exports.InventoryLocationsResource = InventoryLocationsResource;

package/dist/inventory/movements.d.ts

@@ -0,0 +1,36 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { InventoryMovementEntity } from '@managemint-solutions/entities/inventory';
+import type { InventoryMovementType, InventoryReferenceType } from '@managemint-solutions/entities/inventory/enum';
+import type { GetInventoryMovementsDto } from '@managemint-solutions/entities/inventory/dto';
+import { type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/** One ledger row as written: the signed quantity and what caused it. */
+export type CreateInventoryMovementRow = {
+    item_id: string;
+    location_id: string;
+    type: InventoryMovementType;
+    quantity: number;
+    unit_cost_minor?: number | null;
+    reason?: string;
+    reference_type?: InventoryReferenceType | null;
+    reference_id?: string | null;
+    supplier?: string;
+    supplier_reference?: string;
+    notes?: string;
+};
+/**
+ * The ledger. Insert and read only: the table has no update or delete grant, so a mistake is
+ * reversed by an opposite movement and both stay on record. The balance it moves is the level
+ * row, which the api updates right after the insert.
+ */
+export declare class InventoryMovementsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    /** A page of movements, newest first, narrowed by item, location or type. */
+    list(query: GetInventoryMovementsDto): Promise<MmsList<InventoryMovementEntity>>;
+    /** Whether the item has any history - the guard in front of deleting it. */
+    existsForItem(itemId: string): Promise<boolean>;
+    create(input: CreateInventoryMovementRow): Promise<string>;
+}

package/dist/inventory/movements.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryMovementsResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const transforms_1 = require("../transforms");
+const items_1 = require("./items");
+const MOVEMENT_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        item:inventory_items!item_id (${items_1.ITEM_IDENTITY_SELECT}),
+        location:inventory_locations!location_id (mms_id, name),
+        type,
+        quantity,
+        unit_cost_minor,
+        reason,
+        reference_type,
+        reference_id,
+        supplier,
+        supplier_reference,
+        notes
+      `;
+/**
+ * The ledger. Insert and read only: the table has no update or delete grant, so a mistake is
+ * reversed by an opposite movement and both stay on record. The balance it moves is the level
+ * row, which the api updates right after the insert.
+ */
+class InventoryMovementsResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_movements',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_MOVEMENTS,
+            related: { entityType: enum_1.AuditTrailEntityType.INVENTORY_ITEMS, column: 'item_id' },
+            identity: ['item_id', 'location_id', 'type', 'quantity'],
+        });
+    }
+    /** A page of movements, newest first, narrowed by item, location or type. */
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let movementsQuery = this.supabase
+            .from('inventory_movements')
+            .select(MOVEMENT_SELECT, { count: 'estimated' })
+            .eq('organization_id', this.auth.organization_id)
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (query.item_id)
+            movementsQuery = movementsQuery.eq('item_id', query.item_id);
+        if (query.location_id)
+            movementsQuery = movementsQuery.eq('location_id', query.location_id);
+        if (query.type)
+            movementsQuery = movementsQuery.eq('type', query.type);
+        const { data, error, count } = await movementsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const rows = (data ?? []).map((row) => ({
+            ...row,
+            quantity: Number(row.quantity),
+        }));
+        return (0, transforms_1.toMmsList)(rows, page, pageSize, count);
+    }
+    /** Whether the item has any history - the guard in front of deleting it. */
+    async existsForItem(itemId) {
+        const { data, error } = await this.supabase
+            .from('inventory_movements')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .eq('item_id', itemId)
+            .limit(1)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data !== null;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            item_id: input.item_id,
+            location_id: input.location_id,
+            type: input.type,
+            quantity: input.quantity,
+            unit_cost_minor: input.unit_cost_minor ?? null,
+            reason: input.reason ?? '',
+            reference_type: input.reference_type ?? null,
+            reference_id: input.reference_id ?? null,
+            supplier: input.supplier ?? '',
+            supplier_reference: input.supplier_reference ?? '',
+            notes: input.notes ?? '',
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return row.mms_id;
+    }
+}
+exports.InventoryMovementsResource = InventoryMovementsResource;

package/dist/inventory/stocktakes.d.ts

@@ -0,0 +1,36 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { InventoryLocationIdentity, InventoryStocktakeLine } from '@managemint-solutions/entities/inventory';
+import type { GetInventoryStocktakesDto } from '@managemint-solutions/entities/inventory/dto';
+import type { UserIdentity } from '@managemint-solutions/entities/users';
+import { type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/** A stocktake as stored: its lines name items by id; the api reads the items alongside. */
+export type InventoryStocktakeRow = {
+    mms_id: string;
+    created_at: string;
+    created_by: UserIdentity | null;
+    location: InventoryLocationIdentity;
+    lines: InventoryStocktakeLine[];
+    has_differences: boolean;
+    notes: string;
+};
+/**
+ * The record of each count of a location, matches included. Insert and read only: what was
+ * found on a day is never edited. The count movements it posts are the api's.
+ */
+export declare class InventoryStocktakesResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    list(query: GetInventoryStocktakesDto & {
+        organization_id?: string | null;
+    }): Promise<MmsList<InventoryStocktakeRow>>;
+    getById(stocktakeId: string): Promise<InventoryStocktakeRow>;
+    create(input: {
+        location_id: string;
+        lines: InventoryStocktakeLine[];
+        has_differences: boolean;
+        notes: string;
+    }): Promise<InventoryStocktakeRow>;
+}

package/dist/inventory/stocktakes.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryStocktakesResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const tenancy_1 = require("../tenancy");
+const transforms_1 = require("../transforms");
+const STOCKTAKE_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        location:inventory_locations!location_id (mms_id, name),
+        lines,
+        has_differences,
+        notes
+      `;
+/**
+ * The record of each count of a location, matches included. Insert and read only: what was
+ * found on a day is never edited. The count movements it posts are the api's.
+ */
+class InventoryStocktakesResource {
+    supabase;
+    auth;
+    table;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_stocktakes',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_STOCKTAKES,
+        });
+    }
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let stocktakesQuery = (0, tenancy_1.scopeToOrganization)(this.supabase
+            .from('inventory_stocktakes')
+            .select((0, tenancy_1.withOrganization)(STOCKTAKE_SELECT, this.auth), { count: 'estimated' }), this.auth)
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (query.organization_id)
+            stocktakesQuery = stocktakesQuery.eq('organization_id', query.organization_id);
+        if (query.location_id)
+            stocktakesQuery = stocktakesQuery.eq('location_id', query.location_id);
+        const { data, error, count } = await stocktakesQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    async getById(stocktakeId) {
+        const { data, error } = await (0, tenancy_1.scopeToOrganization)(this.supabase.from('inventory_stocktakes').select((0, tenancy_1.withOrganization)(STOCKTAKE_SELECT, this.auth)), this.auth)
+            .eq('mms_id', stocktakeId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            ...input,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+}
+exports.InventoryStocktakesResource = InventoryStocktakesResource;

package/dist/inventory/transfers.d.ts

@@ -0,0 +1,73 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { InventoryLocationIdentity, InventoryTransferLine } from '@managemint-solutions/entities/inventory';
+import { InventoryTransferStatus } from '@managemint-solutions/entities/inventory/enum';
+import type { GetInventoryTransfersDto } from '@managemint-solutions/entities/inventory/dto';
+import type { UserIdentity } from '@managemint-solutions/entities/users';
+import { EntityAuditTrail, type AuditActor, type AuditResource } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+/** A transfer as stored: its lines name items by id; the api reads the items alongside. */
+export type InventoryTransferRow = {
+    mms_id: string;
+    created_at: string;
+    created_by: UserIdentity | null;
+    updated_at: string | null;
+    last_updated_by: UserIdentity | null;
+    from_location: InventoryLocationIdentity;
+    to_location: InventoryLocationIdentity;
+    status: InventoryTransferStatus;
+    lines: InventoryTransferLine[];
+    notes: string;
+    sent_at: string | null;
+    sent_by: UserIdentity | null;
+    received_at: string | null;
+    received_by: UserIdentity | null;
+    cancelled_at: string | null;
+    cancelled_by: UserIdentity | null;
+};
+/** What a write may change: the lines, the notes, the status and its stamps. */
+export type UpdateInventoryTransferRow = Partial<{
+    from_location_id: string;
+    to_location_id: string;
+    lines: InventoryTransferLine[];
+    notes: string;
+    status: InventoryTransferStatus;
+    sent_at: string;
+    sent_by: string | null;
+    received_at: string | null;
+    received_by: string | null;
+    cancelled_at: string;
+    cancelled_by: string | null;
+}>;
+/**
+ * Stock on its way between two locations. The lifecycle (draft -> in transit -> received, or
+ * cancelled) and the ledger rows each step posts are the api's; this is the row.
+ */
+export declare class InventoryTransfersResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly table;
+    readonly audit: EntityAuditTrail;
+    constructor(supabase: TypedSupabaseClient, auth: AuditActor, audit: AuditResource);
+    list(query: GetInventoryTransfersDto & {
+        organization_id?: string | null;
+    }): Promise<MmsList<InventoryTransferRow>>;
+    /** Every transfer in transit: what is incoming where. */
+    listInTransit(): Promise<InventoryTransferRow[]>;
+    /** Whether any transfer still names the location - the guard in front of deleting it. */
+    existsForLocation(locationId: string): Promise<boolean>;
+    getById(transferId: string): Promise<InventoryTransferRow>;
+    create(input: {
+        from_location_id: string;
+        to_location_id: string;
+        lines: InventoryTransferLine[];
+        notes: string;
+    }): Promise<InventoryTransferRow>;
+    update(transferId: string, patch: UpdateInventoryTransferRow): Promise<InventoryTransferRow>;
+    /**
+     * A status move that only lands while the transfer still reads `from`: two people sending the
+     * same draft at once post its stock out once. Resolves null when it had already moved on.
+     */
+    updateWhere(transferId: string, from: InventoryTransferStatus, patch: UpdateInventoryTransferRow): Promise<InventoryTransferRow | null>;
+    /** Hard delete; the api allows it on a draft only. */
+    remove(transferId: string): Promise<void>;
+}

package/dist/inventory/transfers.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryTransfersResource = void 0;
+const enum_1 = require("@managemint-solutions/entities/audit-trail/enum");
+const enum_2 = require("@managemint-solutions/entities/inventory/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const tenancy_1 = require("../tenancy");
+const transforms_1 = require("../transforms");
+const TRANSFER_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED},
+        from_location:inventory_locations!from_location_id (mms_id, name),
+        to_location:inventory_locations!to_location_id (mms_id, name),
+        status,
+        lines,
+        notes,
+        sent_at,
+        sent_by:user_profiles!sent_by ${transforms_1.USER_PROFILE_EMBED},
+        received_at,
+        received_by:user_profiles!received_by ${transforms_1.USER_PROFILE_EMBED},
+        cancelled_at,
+        cancelled_by:user_profiles!cancelled_by ${transforms_1.USER_PROFILE_EMBED}
+      `;
+/**
+ * Stock on its way between two locations. The lifecycle (draft -> in transit -> received, or
+ * cancelled) and the ledger rows each step posts are the api's; this is the row.
+ */
+class InventoryTransfersResource {
+    supabase;
+    auth;
+    table;
+    audit;
+    constructor(supabase, auth, audit) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, audit, {
+            table: 'inventory_transfers',
+            entityType: enum_1.AuditTrailEntityType.INVENTORY_TRANSFERS,
+        });
+        this.audit = new audit_1.EntityAuditTrail(supabase, auth, enum_1.AuditTrailEntityType.INVENTORY_TRANSFERS);
+    }
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        let transfersQuery = (0, tenancy_1.scopeToOrganization)(this.supabase
+            .from('inventory_transfers')
+            .select((0, tenancy_1.withOrganization)(TRANSFER_SELECT, this.auth), { count: 'estimated' }), this.auth)
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (query.organization_id)
+            transfersQuery = transfersQuery.eq('organization_id', query.organization_id);
+        if (query.status)
+            transfersQuery = transfersQuery.eq('status', query.status);
+        // The ids are `@IsUUID('7')`-validated by the DTO, so interpolating one is safe.
+        if (query.location_id) {
+            transfersQuery = transfersQuery.or(`from_location_id.eq.${query.location_id},to_location_id.eq.${query.location_id}`);
+        }
+        const { data, error, count } = await transfersQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (0, transforms_1.toMmsList)(data, page, pageSize, count);
+    }
+    /** Every transfer in transit: what is incoming where. */
+    async listInTransit() {
+        return (0, transforms_1.allRows)((from, to) => this.supabase
+            .from('inventory_transfers')
+            .select(TRANSFER_SELECT)
+            .eq('organization_id', this.auth.organization_id)
+            .eq('status', enum_2.InventoryTransferStatus.IN_TRANSIT)
+            .order('mms_id')
+            .range(from, to));
+    }
+    /** Whether any transfer still names the location - the guard in front of deleting it. */
+    async existsForLocation(locationId) {
+        const { data, error } = await this.supabase
+            .from('inventory_transfers')
+            .select('mms_id')
+            .eq('organization_id', this.auth.organization_id)
+            .or(`from_location_id.eq.${locationId},to_location_id.eq.${locationId}`)
+            .limit(1)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data !== null;
+    }
+    async getById(transferId) {
+        const { data, error } = await (0, tenancy_1.scopeToOrganization)(this.supabase.from('inventory_transfers').select((0, tenancy_1.withOrganization)(TRANSFER_SELECT, this.auth)), this.auth)
+            .eq('mms_id', transferId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return data;
+    }
+    async create(input) {
+        const row = await this.table.insert({
+            ...input,
+            status: enum_2.InventoryTransferStatus.DRAFT,
+            organization_id: this.auth.organization_id,
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(row.mms_id);
+    }
+    async update(transferId, patch) {
+        await this.table.update(transferId, {
+            ...patch,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return this.getById(transferId);
+    }
+    /**
+     * A status move that only lands while the transfer still reads `from`: two people sending the
+     * same draft at once post its stock out once. Resolves null when it had already moved on.
+     */
+    async updateWhere(transferId, from, patch) {
+        const row = await this.table.updateWhere(transferId, (query) => query.eq('status', from), {
+            ...patch,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return row ? this.getById(transferId) : null;
+    }
+    /** Hard delete; the api allows it on a draft only. */
+    async remove(transferId) {
+        await this.table.remove(transferId);
+    }
+}
+exports.InventoryTransfersResource = InventoryTransfersResource;

package/dist/organizations/dto.d.ts

@@ -1,5 +1,5 @@
 import type { CreateOrganizationDto as CreateOrganizationDtoType, GetOrganizationsDto as GetOrganizationsDtoType, OrganizationIdDto as OrganizationIdDtoType, UpdateOrganizationDto as UpdateOrganizationDtoType } from '@managemint-solutions/entities/organization/dto';
-import { OrganizationTypes } from '@managemint-solutions/entities/organization/enum';
+import { OrganizationTypes, StockIssueTrigger } from '@managemint-solutions/entities/organization/enum';
 export declare class CreateOrganizationDto implements CreateOrganizationDtoType {
     readonly org_type: OrganizationTypes;
     readonly org_name: string;
@@ -60,6 +60,8 @@ export declare class UpdateOrganizationDto implements UpdateOrganizationDtoType
     readonly marketing_consent?: boolean;
     readonly currency?: string;
     readonly leave_calendar_start_month?: number;
+    readonly stock_issue_on?: StockIssueTrigger;
+    readonly allow_negative_stock?: boolean;
 }
 export declare class OrganizationIdDto implements OrganizationIdDtoType {
     readonly organizationId: string;

package/dist/organizations/dto.js

@@ -226,6 +226,8 @@ class UpdateOrganizationDto {
     marketing_consent;
     currency;
     leave_calendar_start_month;
+    stock_issue_on;
+    allow_negative_stock;
 }
 exports.UpdateOrganizationDto = UpdateOrganizationDto;
 __decorate([
@@ -450,6 +452,16 @@ __decorate([
     (0, class_validator_1.Max)(12, { message: 'Leave year start month must be between 1 and 12' }),
     __metadata("design:type", Number)
 ], UpdateOrganizationDto.prototype, "leave_calendar_start_month", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(enum_1.StockIssueTrigger, { message: 'Stock leaves on issue or on payment' }),
+    __metadata("design:type", String)
+], UpdateOrganizationDto.prototype, "stock_issue_on", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)({ message: 'Allow negative stock must be true or false' }),
+    __metadata("design:type", Boolean)
+], UpdateOrganizationDto.prototype, "allow_negative_stock", void 0);
 // No tenant route takes one - a tenant only ever reaches their own organization - so this is the
 // admin api's `/organizations/:organizationId`.
 class OrganizationIdDto {

package/dist/organizations/index.js

@@ -83,6 +83,8 @@ const ORGANIZATION_SELECT = `
         billing_post_code,
         billing_country,
         leave_calendar_start_month,
+        stock_issue_on,
+        allow_negative_stock,
         billing_cycle_locked,
         modules,
         payment_frequency,

package/dist/permissions/dto.d.ts

@@ -36,6 +36,10 @@ export declare class UpdatePermissionsDto implements UpdatePermissionsDtoType {
     readonly read_leave_requests: boolean;
     readonly update_leave_requests: boolean;
     readonly delete_leave_requests: boolean;
+    readonly create_inventory: boolean;
+    readonly read_inventory: boolean;
+    readonly update_inventory: boolean;
+    readonly delete_inventory: boolean;
     readonly read_invoices: boolean;
     readonly create_users: boolean;
     readonly read_users: boolean;