sailfork / t3code-github / .repos/ alchemy-effect/ packages/ gcp/ src/ CloudIdentity/ Device.ts

import * as cloudidentity from "@distilled.cloud/gcp/cloudidentity_v1";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import type { Providers } from "../Providers.ts";
import {
  encodeOwnershipLine,
  findOwnedDevice,
  getDevice,
  hasOwnershipMarker,
  lastSegment,
  listDevices,
  MAX_ASSET_TAG_LENGTH,
  normalizeCustomer,
  ownedByAlchemy,
  ownershipLabels,
  parseOwnership,
  replaceOnIdentity,
  toPhysicalId,
} from "./internal.ts";
import { resourceNameFromOperation, waitForOperation, waitUntilPresent } from "./operations.ts";

export type DeviceProps = {
  /**
   * Customer that owns the device (`customers/my_customer` or
   * `customers/{customer}`). Immutable — changing it replaces the
   * device.
   * @default "customers/my_customer"
   */
  customer?: string;
  /**
   * Serial number. If omitted, a unique value is generated. Immutable
   * — changing it replaces the device. Only company-owned devices can
   * be created.
   */
  serialNumber?: string;
  /**
   * Device type. Immutable — changing it replaces the device.
   * @default "LINUX"
   */
  deviceType?: cloudidentity.GoogleAppsCloudidentityDevicesV1DeviceDeviceTypeEnum | (string & {});
  /**
   * Asset tag. Devices have no labels field, so Alchemy stores
   * ownership in a `[alchemy …]` prefix and strips it from attributes.
   */
  assetTag?: string;
  /**
   * Host name.
   */
  hostname?: string;
  /**
   * WiFi MAC addresses.
   */
  wifiMacAddresses?: string[];
  /**
   * Partner-specified unique device identifier.
   */
  deviceId?: string;
};

export type Device = Resource<
  "GCP.CloudIdentity.Device",
  DeviceProps,
  {
    /** Resource name `devices/{device}`. */
    name: string;
    /** Device id (last path segment). */
    deviceResourceId: string;
    /** Customer used on create. */
    customer: string;
    /** Serial number. */
    serialNumber: string | undefined;
    /** Device type. */
    deviceType: string | undefined;
    /** Asset tag with the Alchemy ownership prefix stripped. */
    assetTag: string | undefined;
    /** Host name. */
    hostname: string | undefined;
    /** WiFi MAC addresses. */
    wifiMacAddresses: string[] | undefined;
    /** Partner device id. */
    deviceId: string | undefined;
    /** Owner type (`COMPANY` or `BYOD`). */
    ownerType: string | undefined;
    /** Management state. */
    managementState: string | undefined;
    /** Compromised state. */
    compromisedState: string | undefined;
    /** Encryption state. */
    encryptionState: string | undefined;
    /** RFC3339 import timestamp. */
    createTime: string | undefined;
    /** Last sync time. */
    lastSyncTime: string | undefined;
  },
  never,
  Providers
>;

/**
 * A Cloud Identity company-owned device.
 *
 * Device create is limited to company-owned inventory (Enterprise /
 * Cloud Identity Premium). There is no update API — serial number,
 * type, and customer are identity. Alchemy stamps ownership into
 * `assetTag` for `list` / nuke.
 *
 * ### Creating a Device
 * **Example:** Generated serial
 * ```typescript
 * const device = yield* GCP.CloudIdentity.Device("Laptop", {
 *   deviceType: "LINUX",
 *   hostname: "eng-laptop",
 * });
 * ```
 *
 * **Example:** Explicit serial and asset tag
 * ```typescript
 * const device = yield* GCP.CloudIdentity.Device("Laptop", {
 *   serialNumber: "HT82V1A01076",
 *   deviceType: "LINUX",
 *   assetTag: "desk-14",
 * });
 * ```
 *
 * @resource
 * @category CloudIdentity
 */
export const Device = Resource<Device>("GCP.CloudIdentity.Device");

export class DeviceNotResolved extends Data.TaggedError("GCP.CloudIdentity.DeviceNotResolved")<{
  resourceName: string;
}> {}

const DEFAULT_DEVICE_TYPE = "LINUX";

const toAttrs = (
  device: cloudidentity.GoogleAppsCloudidentityDevicesV1Device,
  customer: string,
) => {
  const name = device.name ?? "";
  return {
    name,
    deviceResourceId: lastSegment(name),
    customer,
    serialNumber: device.serialNumber,
    deviceType: device.deviceType,
    assetTag: parseOwnership(device.assetTag).text,
    hostname: device.hostname,
    wifiMacAddresses: device.wifiMacAddresses,
    deviceId: device.deviceId,
    ownerType: device.ownerType,
    managementState: device.managementState,
    compromisedState: device.compromisedState,
    encryptionState: device.encryptionState,
    createTime: device.createTime,
    lastSyncTime: device.lastSyncTime,
  };
};

const observeDevice = (input: {
  id: string;
  name?: string;
  serialNumber?: string;
  customer: string;
}) =>
  Effect.gen(function* () {
    const byName = yield* getDevice(input.name ?? "", input.customer);
    if (byName !== undefined) return byName;
    return yield* findOwnedDevice(input.id, input.serialNumber, input.customer);
  });

export const DeviceProvider = () =>
  Provider.succeed(Device, {
    stables: ["name", "deviceResourceId", "customer", "serialNumber", "createTime"],

    diff: Effect.fn(function* ({ news, olds, output }) {
      if (!isResolved(news)) return undefined;
      const previousCustomer = olds?.customer ?? output?.customer;
      const nextCustomer =
        news.customer !== undefined ? normalizeCustomer(news.customer) : previousCustomer;
      const previousType = olds?.deviceType ?? output?.deviceType;
      const nextType = news.deviceType ?? DEFAULT_DEVICE_TYPE;
      return replaceOnIdentity({
        previousId: olds?.serialNumber ?? output?.serialNumber,
        nextId: news.serialNumber,
        previousParent: previousCustomer,
        nextParent: nextCustomer,
        extra: previousType !== undefined && previousType !== nextType,
      });
    }),

    read: Effect.fn(function* ({ id, olds, output }) {
      const customer = normalizeCustomer(olds?.customer ?? output?.customer);
      const existing = yield* observeDevice({
        id,
        name: output?.name,
        serialNumber: olds?.serialNumber ?? output?.serialNumber,
        customer,
      });
      if (existing === undefined) return undefined;
      const attrs = toAttrs(existing, customer);
      return (yield* ownedByAlchemy(id, existing.assetTag)) ? attrs : Unowned(attrs);
    }),

    list: () =>
      Effect.gen(function* () {
        const devices = yield* listDevices();
        return devices
          .filter((device) => hasOwnershipMarker(device.assetTag))
          .map((device) => toAttrs(device, DEFAULT_CUSTOMER_FALLBACK));
      }),

    reconcile: Effect.fn(function* ({ id, news, output }) {
      const customer = normalizeCustomer(news.customer ?? output?.customer);
      const ownership = yield* ownershipLabels(id);
      const serialNumber = yield* toPhysicalId(id, news.serialNumber, output?.serialNumber, 20);
      const assetTag = encodeOwnershipLine(ownership, news.assetTag, MAX_ASSET_TAG_LENGTH);
      const deviceType = news.deviceType ?? DEFAULT_DEVICE_TYPE;
      const desired: cloudidentity.GoogleAppsCloudidentityDevicesV1Device = {
        serialNumber,
        deviceType,
        assetTag,
        hostname: news.hostname,
        wifiMacAddresses: news.wifiMacAddresses,
        deviceId: news.deviceId,
      };

      let current = yield* observeDevice({
        id,
        name: output?.name,
        serialNumber,
        customer,
      });

      if (current === undefined) {
        const created = yield* cloudidentity
          .createDevices({
            customer,
            body: desired,
          })
          .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
        if (created !== undefined) {
          yield* waitForOperation(created).pipe(
            Effect.catchTag("GCP.CloudIdentity.OperationPending", () => Effect.void),
          );
          const createdName = resourceNameFromOperation(created);
          if (createdName !== undefined) {
            current = yield* getDevice(createdName, customer);
          }
        }
        if (current === undefined) {
          current = yield* waitUntilPresent(
            observeDevice({
              id,
              name: output?.name,
              serialNumber,
              customer,
            }),
            serialNumber,
          ).pipe(
            Effect.catchTag("GCP.CloudIdentity.OperationPending", () =>
              observeDevice({ id, serialNumber, customer }),
            ),
          );
        }
      }

      if (current === undefined) {
        return yield* new DeviceNotResolved({
          resourceName: output?.name ?? serialNumber,
        });
      }

      return toAttrs(current, customer);
    }),

    delete: Effect.fn(function* ({ output }) {
      if (output.name.length === 0) return;
      const deleted = yield* cloudidentity
        .deleteDevices({
          name: output.name,
          customer: normalizeCustomer(output.customer),
        })
        .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
      if (deleted !== undefined) {
        yield* waitForOperation(deleted, { notFoundOk: true });
      }
    }),
  });

const DEFAULT_CUSTOMER_FALLBACK = "customers/my_customer";