@deterministic-code/datasources 0.1.0 → 0.1.1

package/src/tests/contact/ContactsService.ts

@@ -0,0 +1,32 @@
+import type { ICRUDRepository } from "../../ICRUDRepository.ts";
+import type { IEnriched } from "../../IEnriched.ts";
+import type { IReadonlyRepository } from "../../IReadonlyRepository.ts";
+import type { Address } from "./Address.ts";
+import type { AddressType } from "./AddressType.ts";
+import type { Contact } from "./Contact.ts";
+import type { ContactSource } from "./ContactSource.ts";
+import type { ContactType } from "./ContactType.ts";
+import type { Phone } from "./Phone.ts";
+import type { PhoneType } from "./PhoneType.ts";
+
+type EnrichedCRUD<T> = ICRUDRepository<T> & IEnriched<T>;
+
+export const ContactsService = {
+  open(
+    contacts: EnrichedCRUD<Contact>,
+    types: IReadonlyRepository<ContactType>,
+    sources: IReadonlyRepository<ContactSource>,
+    addressTypes: IReadonlyRepository<AddressType>,
+    phoneTypes: IReadonlyRepository<PhoneType>,
+    addresses: EnrichedCRUD<Address>,
+    phones: EnrichedCRUD<Phone>,
+  ): EnrichedCRUD<Contact> {
+    addresses.addEnriched({ destinationProperty: "AddressType", sourceProperty: "AddressType", relatedKey: "Id" }, addressTypes);
+    phones.addEnriched({ destinationProperty: "PhoneType", sourceProperty: "PhoneType", relatedKey: "Id" }, phoneTypes);
+    contacts.addEnriched({ destinationProperty: "ContactType", sourceProperty: "ContactType", relatedKey: "Id" }, types);
+    contacts.addEnriched({ destinationProperty: "ContactSource", sourceProperty: "ContactSource", relatedKey: "Id" }, sources);
+    contacts.addEnriched({ destinationProperty: "Addresses", sourceProperty: "Id", relatedKey: "Contact", type: "list" }, addresses);
+    contacts.addEnriched({ destinationProperty: "Phones", sourceProperty: "Id", relatedKey: "Contact", type: "list" }, phones);
+    return contacts;
+  },
+};

package/src/tests/contact/ImportContactRequest.ts

@@ -0,0 +1,4 @@
+export class ImportContactRequest {
+  source = "";
+  payload = "";
+}

package/src/tests/contact/ImportContactResult.ts

@@ -0,0 +1,5 @@
+export class ImportContactResult {
+  imported_count = 0;
+  skipped_count = 0;
+  failed_count = 0;
+}

package/src/tests/contact/LegacyContact.ts

@@ -0,0 +1,7 @@
+export class LegacyContact {
+  key = "";
+  first_name = "";
+  last_name = "";
+  email: string | null = null;
+  imported_at: Date | null = null;
+}

package/src/tests/contact/LegacyMigrationResult.ts

@@ -0,0 +1,5 @@
+export class LegacyMigrationResult {
+  migrated_count = 0;
+  skipped_count = 0;
+  completed_at: Date | null = null;
+}

package/src/tests/contact/Phone.ts

@@ -0,0 +1,9 @@
+import { Base } from "./Base.ts";
+import { Contact } from "./Contact.ts";
+import { PhoneType } from "./PhoneType.ts";
+
+export class Phone extends Base {
+  Contact = new Contact();
+  PhoneType = new PhoneType();
+  Number = "";
+}

package/src/tests/contact/PhoneType.ts

@@ -0,0 +1,6 @@
+import { Base } from "./Base.ts";
+
+export class PhoneType extends Base {
+  Name = "";
+  Description: string | null = null;
+}

package/src/tests/contact/asContactsView.ts

@@ -0,0 +1,63 @@
+import type { Contact } from "./Contact.ts";
+
+type AddressView = { id: number; line1: string; city: string; address_type_name: string };
+type PhoneView = { id: number; number: string; phone_type_name: string };
+
+export type ContactsView = {
+  id: number;
+  first_name: string;
+  last_name: string;
+  email: string | null;
+  contact_source_name: string;
+  contact_type_name: string;
+  addresses: AddressView[];
+  phones: PhoneView[];
+};
+
+const byId = (left: { id: number }, right: { id: number }) => left.id - right.id;
+
+export const fromContacts = (contacts: Contact[]): ContactsView[] =>
+  contacts
+    .map((contact) => ({
+      id: contact.Id,
+      first_name: contact.FirstName,
+      last_name: contact.LastName,
+      email: contact.Email,
+      contact_source_name: contact.ContactSource.Name,
+      contact_type_name: contact.ContactType.Name,
+      addresses: contact.Addresses.map((address) => ({
+        id: address.Id,
+        line1: address.Line1,
+        city: address.City,
+        address_type_name: address.AddressType.Name,
+      })).sort(byId),
+      phones: contact.Phones.map((phone) => ({
+        id: phone.Id,
+        number: phone.Number,
+        phone_type_name: phone.PhoneType.Name,
+      })).sort(byId),
+    }))
+    .sort(byId);
+
+export const asContactsView = (contacts: ContactsView[]): ContactsView[] =>
+  [...contacts]
+    .sort(byId)
+    .map((contact) => ({
+      id: contact.id,
+      first_name: contact.first_name,
+      last_name: contact.last_name,
+      email: contact.email,
+      contact_source_name: contact.contact_source_name,
+      contact_type_name: contact.contact_type_name,
+      addresses: [...contact.addresses]
+        .map(({ id, line1, city, address_type_name }) => ({
+          id,
+          line1,
+          city,
+          address_type_name,
+        }))
+        .sort(byId),
+      phones: [...contact.phones]
+        .map(({ id, number, phone_type_name }) => ({ id, number, phone_type_name }))
+        .sort(byId),
+    }));

package/src/tests/contact/contactColumns.ts

@@ -0,0 +1,40 @@
+import { ChangeCasingMapper } from "../../mappers/ChangeCasingMapper.ts";
+import { DictionaryMapper } from "../../mappers/DictionaryMapper.ts";
+import type { IMapper } from "../../mappers/IMapper.ts";
+import { TransformMapper } from "../../mappers/TransformMapper.ts";
+
+export const snake = new ChangeCasingMapper("pascalCase", "snakeCase");
+
+const references = new DictionaryMapper<string>([
+  ["Contact", "contact_id"],
+  ["AddressType", "address_type_id"],
+  ["ContactType", "contact_type_id"],
+  ["ContactSource", "contact_source_id"],
+  ["PhoneType", "phone_type_id"],
+  ["Line1", "line1"],
+  ["Line2", "line2"],
+]);
+
+export const columns: IMapper<string, string> = new TransformMapper(
+  (name) => {
+    const mapped = references.map(name);
+    return mapped !== name ? mapped : snake.map(name);
+  },
+  (name) => {
+    const from = references.reverseMap(name);
+    return from !== name ? from : snake.reverseMap(name);
+  },
+);
+
+export const contactEntity = new DictionaryMapper<string>([["Contact", "contacts_base"]]);
+
+export const joinEntity: IMapper<string, string> = new TransformMapper(
+  (name) => {
+    const mapped = contactEntity.map(name);
+    return mapped !== name ? mapped : snake.map(name);
+  },
+  (name) => {
+    const from = contactEntity.reverseMap(name);
+    return from !== name ? from : snake.reverseMap(name);
+  },
+);

package/src/tests/contact/contactLookupIds.ts

@@ -0,0 +1,32 @@
+import { Operator, Where } from "../../statements/index.ts";
+import type { IConnection } from "../../IConnection.ts";
+import { CRUDRepository } from "../../CRUDRepository.ts";
+import type { Constructable } from "../../converters/Constructable.ts";
+import { AddressType } from "./AddressType.ts";
+import { columns, snake } from "./contactColumns.ts";
+import type { ContactLookups } from "./contactLookups.ts";
+import { ContactSource } from "./ContactSource.ts";
+import { ContactType } from "./ContactType.ts";
+import { PhoneType } from "./PhoneType.ts";
+
+const of = async <T extends { Id: number }>(
+  connection: IConnection,
+  type: Constructable<T>,
+  name: string,
+): Promise<number> => {
+  const row = await new CRUDRepository(connection, {
+    type,
+    entityMapper: snake,
+    propertyMappings: columns,
+    ids: ["Id"],
+  }).readSingle(new Where(new Operator.Equals("Name", name)));
+  if (!row) throw new Error(`${type.name} '${name}' missing`);
+  return row.Id;
+};
+
+export const contactLookupIds = async (connection: IConnection): Promise<ContactLookups> => ({
+  ContactSourceId: await of(connection, ContactSource, "Web"),
+  ContactTypeId: await of(connection, ContactType, "Person"),
+  AddressTypeId: await of(connection, AddressType, "Home"),
+  PhoneTypeId: await of(connection, PhoneType, "Mobile"),
+});

package/src/tests/contact/contactLookups.ts

@@ -0,0 +1,6 @@
+export type ContactLookups = {
+  ContactSourceId: number;
+  ContactTypeId: number;
+  AddressTypeId: number;
+  PhoneTypeId: number;
+};

package/src/tests/contact/contactsParity.ts

@@ -0,0 +1,63 @@
+import { collectAsync } from "../../collectAsync.ts";
+import { ConsoleCommandMiddleware } from "../../ConsoleCommandMiddleware.ts";
+import type { Cells } from "../../converters/Cell.ts";
+import { FlatToNestedMapper } from "../../mappers/FlatToNestedMapper.ts";
+import type { IConnection } from "../../IConnection.ts";
+import { CRUDRepository } from "../../CRUDRepository.ts";
+import { Join, SelectStatement, type ISelectStatement, type IWhere } from "../../index.ts";
+import { fromContacts, type ContactsView } from "./asContactsView.ts";
+import { columns, joinEntity } from "./contactColumns.ts";
+import { contactsServiceOf } from "./contactsServiceOf.ts";
+import { contactsView } from "./contactsView.ts";
+
+export const contactsJoinSelect = (where?: IWhere): ISelectStatement =>
+  new SelectStatement({
+    table: "Contact",
+    fields: [
+      "Contact.Id AS Id",
+      "Contact.FirstName AS FirstName",
+      "Contact.LastName AS LastName",
+      "Contact.Email AS Email",
+      "ContactSource.Name AS ContactSourceName",
+      "ContactType.Name AS ContactTypeName",
+      "Address.Id AS AddressId",
+      "Address.Line1 AS Line1",
+      "Address.City AS City",
+      "AddressType.Name AS AddressTypeName",
+      "Phone.Id AS PhoneId",
+      "Phone.Number AS Number",
+      "PhoneType.Name AS PhoneTypeName",
+    ],
+    joins: [
+      Join.inner("ContactSource", "Contact.ContactSourceId", "ContactSource.Id"),
+      Join.inner("ContactType", "Contact.ContactTypeId", "ContactType.Id"),
+      Join.left("Address", "Contact.Id", "Address.ContactId"),
+      Join.left("AddressType", "Address.AddressTypeId", "AddressType.Id"),
+      Join.left("Phone", "Contact.Id", "Phone.ContactId"),
+      Join.left("PhoneType", "Phone.PhoneTypeId", "PhoneType.Id"),
+    ],
+    where,
+  });
+
+export const contactsParity = async (
+  connection: IConnection,
+  verbose: boolean,
+): Promise<{ eager: ContactsView[]; enriched: ContactsView[] }> => {
+  const middleware = new ConsoleCommandMiddleware(undefined, undefined, {
+    isVerbose: verbose ? "true" : "false",
+  });
+  const eager = new FlatToNestedMapper(contactsView).map(
+    await collectAsync(
+      new CRUDRepository<Cells>(connection, {
+        entityMapper: joinEntity,
+        propertyMappings: columns,
+      })
+        .addMiddleware(middleware)
+        .read(contactsJoinSelect()),
+    ),
+  );
+  const enriched = fromContacts(
+    await collectAsync(contactsServiceOf(connection, verbose ? middleware : undefined).read()),
+  );
+  return { eager, enriched };
+};

package/src/tests/contact/contactsServiceOf.ts

@@ -0,0 +1,38 @@
+import type { ICommandMiddleware } from "../../ICommandMiddleware.ts";
+import type { IConnection } from "../../IConnection.ts";
+import { CRUDRepository } from "../../CRUDRepository.ts";
+import type { Constructable } from "../../converters/Constructable.ts";
+import type { IMapper } from "../../mappers/IMapper.ts";
+import { Address } from "./Address.ts";
+import { AddressType } from "./AddressType.ts";
+import { columns, contactEntity, snake } from "./contactColumns.ts";
+import { Contact } from "./Contact.ts";
+import { ContactSource } from "./ContactSource.ts";
+import { ContactType } from "./ContactType.ts";
+import { ContactsService } from "./ContactsService.ts";
+import { Phone } from "./Phone.ts";
+import { PhoneType } from "./PhoneType.ts";
+
+export const contactsServiceOf = (
+  connection: IConnection,
+  middleware?: ICommandMiddleware,
+) => {
+  const of = <T>(type: Constructable<T>, entity?: IMapper<string, string>) => {
+    const repo = new CRUDRepository(connection, {
+      type,
+      entityMapper: entity ?? snake,
+      propertyMappings: columns,
+      ids: ["Id"],
+    });
+    return middleware ? repo.addMiddleware(middleware) : repo;
+  };
+  return ContactsService.open(
+    of(Contact, contactEntity),
+    of(ContactType),
+    of(ContactSource),
+    of(AddressType),
+    of(PhoneType),
+    of(Address),
+    of(Phone),
+  );
+};

package/src/tests/contact/contactsView.ts

@@ -0,0 +1,31 @@
+import type { TypeMap } from "../../mappers/TypeMap.ts";
+import type { Contact } from "./Contact.ts";
+
+export const contactsView: TypeMap<Contact> = {
+  key: "id",
+  fields: {
+    id: "Id",
+    first_name: "FirstName",
+    last_name: "LastName",
+    email: "Email",
+    contact_source_name: "ContactSourceName",
+    contact_type_name: "ContactTypeName",
+    addresses: {
+      key: "AddressId",
+      fields: {
+        id: "AddressId",
+        line1: "Line1",
+        city: "City",
+        address_type_name: "AddressTypeName",
+      },
+    },
+    phones: {
+      key: "PhoneId",
+      fields: {
+        id: "PhoneId",
+        number: "Number",
+        phone_type_name: "PhoneTypeName",
+      },
+    },
+  },
+};

package/src/tests/contact/expectContactsView.ts

@@ -0,0 +1,23 @@
+import { expect } from "vitest";
+
+type View = { id: number; addresses: unknown[]; phones: unknown[] };
+
+export const contactWith = <T extends View>(
+  contacts: T[],
+  addresses: number,
+  phones: number,
+): T => {
+  const contact = contacts.find(
+    (item) => item.addresses.length === addresses && item.phones.length === phones,
+  );
+  if (!contact) throw new Error(`no contact with ${addresses} addresses and ${phones} phones`);
+  return contact;
+};
+
+export const expectContactsView = (contacts: View[], count: number) => {
+  expect(contacts).toHaveLength(count);
+  contactWith(contacts, 2, 1);
+  contactWith(contacts, 0, 1);
+  contactWith(contacts, 2, 0);
+  contactWith(contacts, 0, 0);
+};

package/src/tests/contact/extraContact.ts

@@ -0,0 +1,61 @@
+import { Operator, Where } from "../../statements/index.ts";
+import { collectAsync } from "../../collectAsync.ts";
+import type { ICRUDRepository } from "../../ICRUDRepository.ts";
+import { Address } from "./Address.ts";
+import { AddressType } from "./AddressType.ts";
+import { Contact } from "./Contact.ts";
+import { ContactSource } from "./ContactSource.ts";
+import { ContactType } from "./ContactType.ts";
+import type { ContactLookups } from "./contactLookups.ts";
+import { Phone } from "./Phone.ts";
+import { PhoneType } from "./PhoneType.ts";
+
+const stamp = new Date("2024-01-01T00:00:00Z");
+const version = new Uint8Array();
+
+const base = <T extends { Uuid: string; Created: Date; Updated: Date; Version: Uint8Array }>(
+  type: { new (): T },
+  extra: Partial<T>,
+): T =>
+  Object.assign(new type(), {
+    Uuid: crypto.randomUUID(),
+    Created: stamp,
+    Updated: stamp,
+    Version: version,
+    ...extra,
+  });
+
+export const extraContact = (ids: ContactLookups): Contact =>
+  base(Contact, {
+    ContactSource: Object.assign(new ContactSource(), { Id: ids.ContactSourceId }),
+    ContactType: Object.assign(new ContactType(), { Id: ids.ContactTypeId }),
+    FirstName: "Extra",
+    LastName: "Contact",
+    Addresses: [
+      base(Address, {
+        AddressType: Object.assign(new AddressType(), { Id: ids.AddressTypeId }),
+        Line1: "9 Extra",
+        City: "Oslo",
+      }),
+    ],
+    Phones: [
+      base(Phone, {
+        PhoneType: Object.assign(new PhoneType(), { Id: ids.PhoneTypeId }),
+        Number: "555-extra",
+      }),
+    ],
+  });
+
+export const addExtraContact = async (
+  service: ICRUDRepository<Contact>,
+  ids: ContactLookups,
+): Promise<Contact> => {
+  const contact = extraContact(ids);
+  const created = await service.create(contact);
+  if (!(created.Id > 0)) throw new Error("create returned no id");
+  const loaded = (
+    await collectAsync(service.read(new Where(new Operator.Equals("Id", contact.Id))))
+  )[0];
+  if (!loaded) throw new Error("extra contact missing after create");
+  return loaded;
+};

package/src/tests/contact/logMapped.ts

@@ -0,0 +1,5 @@
+export const logMapped = (value: object): void => {
+  console.log(
+    `[${new Date().toISOString()}]-[datasource][Mapped]-[${JSON.stringify(value)}]`,
+  );
+};

package/src/tests/contact/seedContacts.ts

@@ -0,0 +1,31 @@
+const stamp = "2024-01-01T00:00:00Z";
+const uuid = (n: number) =>
+  `00000000-0000-4000-8000-${n.toString().padStart(12, "0")}`;
+
+export const seedContactsSql = (count = 250, version = "X''"): string[] => {
+  const statements: string[] = [];
+  let addressId = 1;
+  let phoneId = 1;
+  for (let id = 1; id <= count; id++) {
+    const source = (id % 3) + 1;
+    const type = (id % 2) + 1;
+    statements.push(
+      `INSERT INTO "contacts_base" ("id", "uuid", "created", "updated", "version", "contact_source_id", "contact_type_id", "first_name", "last_name", "email", "notes") VALUES (${id}, '${uuid(id)}', '${stamp}', '${stamp}', ${version}, ${source}, ${type}, 'First${id}', 'Last${id}', 'c${id}@ex.com', NULL)`,
+    );
+    for (let a = 0; a < id % 4; a++) {
+      statements.push(
+        `INSERT INTO "address" ("id", "uuid", "created", "updated", "version", "contact_id", "address_type_id", "line1", "line2", "city", "region", "postal_code", "country") VALUES (${addressId}, '${uuid(1000 + addressId)}', '${stamp}', '${stamp}', ${version}, ${id}, ${a === 0 ? 1 : 2}, '${id} Line ${a + 1}', NULL, 'City${id}', NULL, NULL, NULL)`,
+      );
+      addressId += 1;
+    }
+    for (let p = 0; p < id % 3; p++) {
+      statements.push(
+        `INSERT INTO "phone" ("id", "uuid", "created", "updated", "version", "contact_id", "phone_type_id", "number") VALUES (${phoneId}, '${uuid(2000 + phoneId)}', '${stamp}', '${stamp}', ${version}, ${id}, ${p === 0 ? 1 : 2}, '555-000-${id.toString().padStart(4, "0")}-${p}')`,
+      );
+      phoneId += 1;
+    }
+  }
+  return statements;
+};
+
+export const seedContactCount = 250;