@intentius/chant 0.0.1

package/src/types.test.ts

@@ -0,0 +1,307 @@
+import { describe, test, expectTypeOf } from "bun:test";
+import type { Value, AllValues, PartialValues, RequiredProps } from "./types";
+import type { Intrinsic } from "./intrinsic";
+
+describe("Value<T>", () => {
+  test("accepts concrete value", () => {
+    expectTypeOf<string>().toMatchTypeOf<Value<string>>();
+    expectTypeOf<number>().toMatchTypeOf<Value<number>>();
+    expectTypeOf<boolean>().toMatchTypeOf<Value<boolean>>();
+  });
+
+  test("accepts Intrinsic", () => {
+    expectTypeOf<Intrinsic>().toMatchTypeOf<Value<string>>();
+    expectTypeOf<Intrinsic>().toMatchTypeOf<Value<number>>();
+    expectTypeOf<Intrinsic>().toMatchTypeOf<Value<boolean>>();
+  });
+});
+
+describe("AllValues<T>", () => {
+  test("converts all properties to Value types", () => {
+    interface Props {
+      name: string;
+      count: number;
+      enabled: boolean;
+    }
+
+    type ValueProps = AllValues<Props>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: Value<string>;
+      count: Value<number>;
+      enabled: Value<boolean>;
+    }>();
+  });
+
+  test("preserves optional properties", () => {
+    interface Props {
+      required: string;
+      optional?: number;
+    }
+
+    type ValueProps = AllValues<Props>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      required: Value<string>;
+      optional?: Value<number>;
+    }>();
+  });
+
+  test("handles complex types", () => {
+    interface Props {
+      arr: string[];
+      obj: { key: string };
+      union: string | number;
+    }
+
+    type ValueProps = AllValues<Props>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      arr: Value<string[]>;
+      obj: Value<{ key: string }>;
+      union: Value<string | number>;
+    }>();
+  });
+
+  test("handles empty interface", () => {
+    interface Props {}
+
+    type ValueProps = AllValues<Props>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{}>();
+  });
+
+  test("handles nested objects", () => {
+    interface Props {
+      config: {
+        host: string;
+        port: number;
+      };
+    }
+
+    type ValueProps = AllValues<Props>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      config: Value<{
+        host: string;
+        port: number;
+      }>;
+    }>();
+  });
+});
+
+describe("PartialValues<T, K>", () => {
+  test("converts specified properties to Value types", () => {
+    interface Props {
+      name: string;
+      count: number;
+      enabled: boolean;
+    }
+
+    type ValueProps = PartialValues<Props, "name" | "count">;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: Value<string>;
+      count: Value<number>;
+      enabled: boolean;
+    }>();
+  });
+
+  test("converts single property to Value type", () => {
+    interface Props {
+      name: string;
+      count: number;
+    }
+
+    type ValueProps = PartialValues<Props, "name">;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: Value<string>;
+      count: number;
+    }>();
+  });
+
+  test("preserves optional properties", () => {
+    interface Props {
+      name: string;
+      count?: number;
+    }
+
+    type ValueProps = PartialValues<Props, "name">;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: Value<string>;
+      count?: number;
+    }>();
+  });
+
+  test("handles complex types", () => {
+    interface Props {
+      arr: string[];
+      obj: { key: string };
+      primitive: string;
+    }
+
+    type ValueProps = PartialValues<Props, "arr" | "obj">;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      arr: Value<string[]>;
+      obj: Value<{ key: string }>;
+      primitive: string;
+    }>();
+  });
+
+  test("works with all properties", () => {
+    interface Props {
+      name: string;
+      count: number;
+    }
+
+    type ValueProps = PartialValues<Props, "name" | "count">;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: Value<string>;
+      count: Value<number>;
+    }>();
+  });
+
+  test("works with no conversion (unrealistic but valid)", () => {
+    interface Props {
+      name: string;
+      count: number;
+    }
+
+    type ValueProps = PartialValues<Props, never>;
+
+    expectTypeOf<ValueProps>().toEqualTypeOf<{
+      name: string;
+      count: number;
+    }>();
+  });
+});
+
+describe("RequiredProps<T, K>", () => {
+  test("makes specified properties required", () => {
+    interface Props {
+      name?: string;
+      count?: number;
+      enabled?: boolean;
+    }
+
+    type RequiredNameProps = RequiredProps<Props, "name">;
+
+    expectTypeOf<RequiredNameProps>().toEqualTypeOf<{
+      name: string;
+      count?: number;
+      enabled?: boolean;
+    }>();
+  });
+
+  test("makes multiple properties required", () => {
+    interface Props {
+      name?: string;
+      count?: number;
+      enabled?: boolean;
+    }
+
+    type RequiredMultiProps = RequiredProps<Props, "name" | "count">;
+
+    expectTypeOf<RequiredMultiProps>().toEqualTypeOf<{
+      name: string;
+      count: number;
+      enabled?: boolean;
+    }>();
+  });
+
+  test("handles already required properties", () => {
+    interface Props {
+      name: string;
+      count?: number;
+    }
+
+    type RequiredNameProps = RequiredProps<Props, "name">;
+
+    expectTypeOf<RequiredNameProps>().toEqualTypeOf<{
+      name: string;
+      count?: number;
+    }>();
+  });
+
+  test("makes all properties required", () => {
+    interface Props {
+      name?: string;
+      count?: number;
+    }
+
+    type AllRequiredProps = RequiredProps<Props, "name" | "count">;
+
+    expectTypeOf<AllRequiredProps>().toEqualTypeOf<{
+      name: string;
+      count: number;
+    }>();
+  });
+
+  test("handles complex types", () => {
+    interface Props {
+      arr?: string[];
+      obj?: { key: string };
+      primitive?: string;
+    }
+
+    type RequiredArrProps = RequiredProps<Props, "arr">;
+
+    expectTypeOf<RequiredArrProps>().toEqualTypeOf<{
+      arr: string[];
+      obj?: { key: string };
+      primitive?: string;
+    }>();
+  });
+
+  test("handles mixed required and optional", () => {
+    interface Props {
+      required: string;
+      optional1?: number;
+      optional2?: boolean;
+    }
+
+    type PartiallyRequired = RequiredProps<Props, "optional1">;
+
+    expectTypeOf<PartiallyRequired>().toEqualTypeOf<{
+      required: string;
+      optional1: number;
+      optional2?: boolean;
+    }>();
+  });
+});
+
+describe("Combined usage", () => {
+  test("AllValues and RequiredProps can be combined", () => {
+    interface Props {
+      name?: string;
+      count?: number;
+    }
+
+    type Combined = AllValues<RequiredProps<Props, "name">>;
+
+    expectTypeOf<Combined>().toEqualTypeOf<{
+      name: Value<string>;
+      count?: Value<number>;
+    }>();
+  });
+
+  test("PartialValues and RequiredProps can be combined", () => {
+    interface Props {
+      name?: string;
+      count?: number;
+      enabled?: boolean;
+    }
+
+    type Combined = PartialValues<RequiredProps<Props, "name">, "count">;
+
+    expectTypeOf<Combined>().toEqualTypeOf<{
+      name: string;
+      count?: Value<number>;
+      enabled?: boolean;
+    }>();
+  });
+});

package/src/types.ts

@@ -0,0 +1,46 @@
+import type { Intrinsic } from "./intrinsic";
+
+/**
+ * Value type that can be either a concrete value T or an Intrinsic
+ */
+export type Value<T> = T | Intrinsic;
+
+/**
+ * Converts all properties of T to Value<T> types
+ *
+ * @example
+ * ```ts
+ * interface Props { name: string; count: number }
+ * type ValueProps = AllValues<Props>
+ * // Result: { name: Value<string>; count: Value<number> }
+ * ```
+ */
+export type AllValues<T> = {
+  [K in keyof T]: Value<T[K]>;
+};
+
+/**
+ * Makes specific properties K of T be Value types while keeping others unchanged
+ *
+ * @example
+ * ```ts
+ * interface Props { name: string; count: number; enabled: boolean }
+ * type ValueProps = PartialValues<Props, 'name' | 'count'>
+ * // Result: { name: Value<string>; count: Value<number>; enabled: boolean }
+ * ```
+ */
+export type PartialValues<T, K extends keyof T> = {
+  [P in keyof T]: P extends K ? Value<T[P]> : T[P];
+};
+
+/**
+ * Makes specific properties K of T required while keeping others unchanged
+ *
+ * @example
+ * ```ts
+ * interface Props { name?: string; count?: number; enabled?: boolean }
+ * type RequiredNameProps = RequiredProps<Props, 'name'>
+ * // Result: { name: string; count?: number; enabled?: boolean }
+ * ```
+ */
+export type RequiredProps<T, K extends keyof T> = T & Required<Pick<T, K>>;

package/src/utils.test.ts

@@ -0,0 +1,195 @@
+import { describe, test, expect } from "bun:test";
+import {
+  LOGICAL_NAME_SYMBOL,
+  getAttributes,
+  getLogicalName,
+} from "./utils";
+import { AttrRef } from "./attrref";
+import type { Declarable } from "./declarable";
+import { DECLARABLE_MARKER } from "./declarable";
+
+describe("LOGICAL_NAME_SYMBOL", () => {
+  test("is a symbol", () => {
+    expect(typeof LOGICAL_NAME_SYMBOL).toBe("symbol");
+  });
+
+  test("uses Symbol.for for global registry", () => {
+    expect(LOGICAL_NAME_SYMBOL).toBe(Symbol.for("chant.logicalName"));
+  });
+});
+
+describe("getAttributes", () => {
+  test("returns empty array for entity with no AttrRef properties", () => {
+    const entity: Declarable = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      prop1: "value",
+      prop2: 123,
+    };
+
+    const attributes = getAttributes(entity);
+    expect(attributes).toEqual([]);
+  });
+
+  test("returns property names with AttrRef values", () => {
+    const parent = {};
+    const entity: Declarable & { arn: AttrRef; name: AttrRef } = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      arn: new AttrRef(parent, "Arn"),
+      name: new AttrRef(parent, "Name"),
+    };
+
+    const attributes = getAttributes(entity);
+    expect(attributes).toContain("arn");
+    expect(attributes).toContain("name");
+    expect(attributes).toHaveLength(2);
+  });
+
+  test("ignores non-AttrRef properties", () => {
+    const parent = {};
+    const entity: Declarable & {
+      arn: AttrRef;
+      regularProp: string;
+      numberProp: number;
+    } = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      arn: new AttrRef(parent, "Arn"),
+      regularProp: "value",
+      numberProp: 42,
+    };
+
+    const attributes = getAttributes(entity);
+    expect(attributes).toEqual(["arn"]);
+  });
+
+  test("returns attributes in order they appear", () => {
+    const parent = {};
+    const entity: Declarable & {
+      first: AttrRef;
+      second: AttrRef;
+      third: AttrRef;
+    } = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      first: new AttrRef(parent, "First"),
+      second: new AttrRef(parent, "Second"),
+      third: new AttrRef(parent, "Third"),
+    };
+
+    const attributes = getAttributes(entity);
+    expect(attributes).toEqual(["first", "second", "third"]);
+  });
+
+  test("handles entity with mixed property types", () => {
+    const parent = {};
+    const entity: Declarable & {
+      attrRef: AttrRef;
+      string: string;
+      number: number;
+      boolean: boolean;
+      object: object;
+      anotherAttrRef: AttrRef;
+    } = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      attrRef: new AttrRef(parent, "Attr1"),
+      string: "test",
+      number: 123,
+      boolean: true,
+      object: {},
+      anotherAttrRef: new AttrRef(parent, "Attr2"),
+    };
+
+    const attributes = getAttributes(entity);
+    expect(attributes).toContain("attrRef");
+    expect(attributes).toContain("anotherAttrRef");
+    expect(attributes).toHaveLength(2);
+  });
+});
+
+describe("getLogicalName", () => {
+  test("returns logical name when set", () => {
+    const entity: Declarable & Record<symbol, unknown> = {
+      entityType: "Test",
+      [DECLARABLE_MARKER]: true,
+      [LOGICAL_NAME_SYMBOL]: "MyResource",
+    };
+
+    const name = getLogicalName(entity);
+    expect(name).toBe("MyResource");
+  });
+
+  test("throws when logical name is not set", () => {
+    const entity: Declarable = {
+      entityType: "TestEntity",
+      [DECLARABLE_MARKER]: true,
+    };
+
+    expect(() => getLogicalName(entity)).toThrow(
+      'Logical name not set on entity of type "TestEntity"'
+    );
+  });
+
+  test("throws when logical name is not a string", () => {
+    const entity: Declarable & Record<symbol, unknown> = {
+      entityType: "TestEntity",
+      [DECLARABLE_MARKER]: true,
+      [LOGICAL_NAME_SYMBOL]: 123,
+    };
+
+    expect(() => getLogicalName(entity)).toThrow(
+      'Logical name not set on entity of type "TestEntity"'
+    );
+  });
+
+  test("handles different logical name values", () => {
+    const names = ["MyBucket", "MyTable", "My-Function-123", "Resource_1"];
+
+    for (const name of names) {
+      const entity: Declarable & Record<symbol, unknown> = {
+        entityType: "Test",
+        [DECLARABLE_MARKER]: true,
+        [LOGICAL_NAME_SYMBOL]: name,
+      };
+
+      expect(getLogicalName(entity)).toBe(name);
+    }
+  });
+
+  test("includes entity type in error message", () => {
+    const entity: Declarable = {
+      entityType: "MyCustomType",
+      [DECLARABLE_MARKER]: true,
+    };
+
+    expect(() => getLogicalName(entity)).toThrow(
+      'Logical name not set on entity of type "MyCustomType"'
+    );
+  });
+
+  test("throws when logical name is undefined", () => {
+    const entity: Declarable & Record<symbol, unknown> = {
+      entityType: "TestEntity",
+      [DECLARABLE_MARKER]: true,
+      [LOGICAL_NAME_SYMBOL]: undefined,
+    };
+
+    expect(() => getLogicalName(entity)).toThrow(
+      'Logical name not set on entity of type "TestEntity"'
+    );
+  });
+
+  test("throws when logical name is null", () => {
+    const entity: Declarable & Record<symbol, unknown> = {
+      entityType: "TestEntity",
+      [DECLARABLE_MARKER]: true,
+      [LOGICAL_NAME_SYMBOL]: null,
+    };
+
+    expect(() => getLogicalName(entity)).toThrow(
+      'Logical name not set on entity of type "TestEntity"'
+    );
+  });
+});

package/src/utils.ts

@@ -0,0 +1,46 @@
+import type { Declarable } from "./declarable";
+import { AttrRef } from "./attrref";
+
+/**
+ * Symbol for storing logical names on Declarable entities
+ */
+export const LOGICAL_NAME_SYMBOL = Symbol.for("chant.logicalName");
+
+/**
+ * Get all property names that have AttrRef values
+ * @param entity - The declarable entity to inspect
+ * @returns Array of property names with AttrRef values
+ */
+export function getAttributes(entity: Declarable): string[] {
+  const attributes: string[] = [];
+  const obj = entity as unknown as Record<string, unknown>;
+
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const value = obj[key];
+      if (value instanceof AttrRef) {
+        attributes.push(key);
+      }
+    }
+  }
+
+  return attributes;
+}
+
+/**
+ * Get the logical name stored on a Declarable entity
+ * @param entity - The declarable entity
+ * @returns The logical name
+ * @throws {Error} If logical name is not set
+ */
+export function getLogicalName(entity: Declarable): string {
+  const logicalName = (entity as unknown as Record<symbol, unknown>)[LOGICAL_NAME_SYMBOL];
+
+  if (typeof logicalName !== "string") {
+    throw new Error(
+      `Logical name not set on entity of type "${entity.entityType}"`
+    );
+  }
+
+  return logicalName;
+}