WE BUILD WEBSITES, STORES & APPS.AND WE HOST.

import { createHash } from 'node:crypto';

export function fingerprint(payload) {
  return createHash('sha256')
    .update(JSON.stringify(payload))
    .digest('hex')
    .slice(0, 12);
}

export async function buildSummary(records) {
  const active = records.filter(
    ({ status }) => status === 'active'
  );

  return Promise.all(active.map(async (record) => ({
    id: fingerprint(record),
    name: record.name.trim(),
    ready: true
  })));
}

from dataclasses import dataclass
from decimal import Decimal
from typing import Iterable

@dataclass(frozen=True)
class LineItem:
    sku: str
    price: Decimal
    quantity: int = 1

def subtotal(items: Iterable[LineItem]) -> Decimal:
    return sum(
        (item.price * item.quantity for item in items),
        start=Decimal("0.00"),
    )

def describe(item: LineItem) -> str:
    return f"{item.sku} × {item.quantity}"

export type EventKind = 'created' | 'updated';

export interface DomainEvent<T> {
  id: string;
  kind: EventKind;
  payload: T;
}

export function mapEvents<T, U>(
  events: readonly DomainEvent<T>[],
  project: (value: T) => U
): DomainEvent<U>[] {
  return events.map((event) => ({
    ...event,
    payload: project(event.payload)
  }));
}

export const isDefined = <T>(
  value: T | null | undefined
): value is T => value != null;

from collections import defaultdict

def group_records(records: list[dict]) -> dict:
    grouped = defaultdict(list)
    for record in records:
        grouped[record["team"]].append(record)
    return dict(grouped)

def compose_context(records: list[dict]) -> str:
    sections = []
    for record in records:
        title = record["title"].strip()
        body = record["body"].strip()
        sections.append(f"{title}\n{body}")
    return "\n\n".join(sections)

import { randomUUID } from 'node:crypto';

export function createJob(payload) {
  return {
    id: randomUUID(),
    status: 'queued',
    payload
  };
}

export async function processQueue(jobs, handler) {
  const completed = [];
  for (const job of jobs) {
    const result = await handler(job.payload);
    completed.push({ id: job.id, result });
  }
  return completed;
}

export type AsyncTask<T> = () => Promise<T>;

export async function runSeries<T>(
  tasks: readonly AsyncTask<T>[]
): Promise<T[]> {
  const results: T[] = [];
  for (const task of tasks) {
    results.push(await task());
  }
  return results;
}

export function indexBy<T, K extends PropertyKey>(
  items: readonly T[],
  key: (item: T) => K
): Map<K, T> {
  return new Map(items.map((item) => [key(item), item]));
}