import { createFlowEngine, ensureFlowReady } from '@classytic/flow';
import mongoose from 'mongoose';

const conn = await mongoose
  .createConnection(process.env.MONGO_URL, { dbName: 'myapp' })
  .asPromise();

const flow = createFlowEngine({
  mongoose: conn,
  mode: 'standard',  // 'simple' | 'standard' | 'enterprise'
  catalog: {
    async resolveSku(skuRef) {
      const sku = await mySkuLookup(skuRef);
      return {
        skuRef,
        sku: sku.code,
        displayName: sku.name,
        trackingMode: sku.trackingMode ?? 'none',
        uom: sku.uom ?? 'unit',
        isActive: true,
      };
    },
  },
});

// Required once at startup — materialises collections + drains index
// builds so the first transactional call never fails.
await ensureFlowReady(flow);

// Reserve 10 units — ordered-lock atomic, race-free under concurrency
const ctx = { organizationId: 'org_1', actorId: 'user_1' };
const result = await flow.services.moveLine.reserveLinesForMove(
  {
    moveId: 'mv_1',
    moveGroupId: 'grp_1',
    skuRef: 'WIDGET-A',
    sourceLocationId: 'STOCK',
    destinationLocationId: 'OUTPUT',
    quantity: 10,
    strategy: 'fefo',
  },
  ctx,
);
console.log(result.lines);  // [{ lotId, quantity, lotExpiresAt, … }]

import express from 'express';
const app = express();

app.post('/reserve', async (req, res) => {
  const result = await flow.services.moveLine.reserveLinesForMove(req.body, {
    organizationId: req.user.orgId,
    actorId: req.user.id,
  });
  res.json(result);
});

import { createFlowEngine, ensureFlowReady } from '@classytic/flow';
import { MemoryEventTransport } from '@classytic/arc/events';

// Arc's EventTransport is structurally identical to the `EventTransport`
// from `@classytic/primitives/events` that flow accepts.
// Pass it directly — no adapter, no bridge, one shared bus.
const transport = new MemoryEventTransport();

const flow = createFlowEngine({
  mongoose: conn,
  mode: 'standard',
  catalog,
  eventTransport: transport,  // flow events land on Arc's bus natively
});
await ensureFlowReady(flow);

// Arc subscribers receive flow events directly:
// subscribe('flow.reservation.created', handler)
// subscribe('flow.package.sealed', handler)

@Module({
  providers: [
    {
      provide: 'FLOW',
      useFactory: () => createFlowEngine({ mongoose: conn, mode: 'standard', catalog }),
    },
  ],
})
export class InventoryModule {}

@Injectable()
export class InventoryService {
  constructor(@Inject('FLOW') private flow: FlowEngine) {}
  reserve(dto, ctx) {
    return this.flow.services.moveLine.reserveLinesForMove(dto, ctx);
  }
}

// Outbox relay cron — call every few seconds
const count = await flow.services.eventLog.relayUndelivered(ctx, 500);
console.log(`Published ${count} events`);

import type { ForecastPort } from '@classytic/flow/procurement';

const forecastPort: ForecastPort = {
  async getForecast({ skuRef, locationId, horizonDays, now }, ctx) {
    const series = await myPlanner.demand({ skuRef, locationId, horizonDays, ctx });
    return { points: series, method: 'croston' };
  },
};

const flow = createFlowEngine({ mongoose: conn, mode: 'standard', catalog, forecastPort });
// ReplenishmentService now sizes triggered rules to
// max(min/max baseline, expectedDemand + safetyStock − projected).

// subscribe() returns Promise<() => void> — same as Arc's EventTransport
const unsub = await flow.events.subscribe('flow.package.sealed', async (event) => {
  await transit.createParcel({
    packageId: event.payload.packageId,
    destination: event.payload.destinationAddress,
  });
});

// Later
unsub();

// Arc's MemoryEventTransport (in-process)
import { MemoryEventTransport } from '@classytic/arc/events';
createFlowEngine({ ..., eventTransport: new MemoryEventTransport() });

// Redis (when you scale out)
import { RedisEventTransport } from '@classytic/arc/events';
createFlowEngine({ ..., eventTransport: new RedisEventTransport(ioredis) });

// Custom Kafka / Temporal / NATS — implement publish + subscribe
createFlowEngine({ ..., eventTransport: myKafkaTransport });