@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/stubs/StubRepository.ts

@@ -0,0 +1,42 @@
+import type { Scalar } from "../builders/Scalar.ts";
+import type { Cells } from "../converters/Cell.ts";
+import type { Constructable } from "../converters/Constructable.ts";
+import type { IConnection } from "../IConnection.ts";
+import type { Parameter } from "../Parameter.ts";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.ts";
+import type { ISelectStatement } from "../statements/ISelectStatement.ts";
+import type { ICRUDRepository } from "../ICRUDRepository.ts";
+import { ReadonlyRepository, untyped } from "../ReadonlyRepository.ts";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.ts";
+import type { Response } from "../Response.ts";
+import type { IWhere } from "../statements/IWhere.ts";
+import { notImplemented } from "./notImplemented.ts";
+
+export class StubRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+  readonly ids: readonly string[] = [];
+  constructor(
+    readonly provider: string,
+    _connection: IConnection,
+    type: Constructable<T> = untyped<T>(),
+  ) {
+    super(type);
+  }
+
+  async *read(
+    _query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement,
+    _parameters?: Parameter[],
+    _options?: ReadonlyRepositoryMappingOptions<T>,
+  ): AsyncIterable<T> {
+    notImplemented(this.provider);
+  }
+
+  create = async (_item: T): Promise<T> => notImplemented(this.provider);
+
+  update = async (_item: T, _byWhere?: IWhere): Promise<Response> =>
+    notImplemented(this.provider);
+
+  delete = async (_item: T, _byWhere?: IWhere): Promise<Response> =>
+    notImplemented(this.provider);
+
+  readSingleById = (_id: Scalar | Cells): Promise<T | undefined> => notImplemented(this.provider);
+}

package/src/stubs/StubTransaction.ts

@@ -0,0 +1,17 @@
+import type { IConnection } from "../IConnection.ts";
+import type { ITransaction } from "../ITransaction.ts";
+import { IsolationLevel } from "../IsolationLevel.ts";
+import { notImplemented } from "./notImplemented.ts";
+
+export class StubTransaction implements ITransaction {
+  readonly isolation = IsolationLevel.ReadCommitted;
+
+  constructor(
+    readonly provider: string,
+    readonly connection: IConnection,
+  ) {}
+
+  commit = async (): Promise<void> => notImplemented(this.provider);
+
+  abort = async (): Promise<void> => notImplemented(this.provider);
+}

package/src/stubs/createStubDatasource.ts

@@ -0,0 +1,4 @@
+import { StubDatasource } from "./StubDatasource.ts";
+
+export const createStubDatasource = (provider: string): StubDatasource =>
+  new StubDatasource(provider);

package/src/stubs/index.ts

@@ -0,0 +1,7 @@
+export { createStubDatasource } from "./createStubDatasource.ts";
+export { StubCommand } from "./StubCommand.ts";
+export { StubConnection } from "./StubConnection.ts";
+export { StubDatasource } from "./StubDatasource.ts";
+export { StubReader } from "./StubReader.ts";
+export { StubRepository } from "./StubRepository.ts";
+export { StubTransaction } from "./StubTransaction.ts";

package/src/stubs/notImplemented.ts

@@ -0,0 +1,5 @@
+import { ProviderNotImplementedError } from "../ProviderNotImplementedError.ts";
+
+export const notImplemented = (provider: string): never => {
+  throw new ProviderNotImplementedError(provider);
+};

package/src/tests/contact/Address.ts

@@ -0,0 +1,14 @@
+import { AddressType } from "./AddressType.ts";
+import { Base } from "./Base.ts";
+import { Contact } from "./Contact.ts";
+
+export class Address extends Base {
+  Contact = new Contact();
+  AddressType = new AddressType();
+  Line1 = "";
+  Line2: string | null = null;
+  City = "";
+  Region: string | null = null;
+  PostalCode: string | null = null;
+  Country: string | null = null;
+}

package/src/tests/contact/AddressType.ts

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

package/src/tests/contact/Base.ts

@@ -0,0 +1,7 @@
+export class Base {
+  Id = 0;
+  Uuid = "";
+  Created = new Date(0);
+  Updated = new Date(0);
+  Version = new Uint8Array();
+}

package/src/tests/contact/Contact.ts

@@ -0,0 +1,12 @@
+import { Address } from "./Address.ts";
+import { ContactBase } from "./ContactBase.ts";
+import { ContactSource } from "./ContactSource.ts";
+import { ContactType } from "./ContactType.ts";
+import { Phone } from "./Phone.ts";
+
+export class Contact extends ContactBase {
+  ContactSource = new ContactSource();
+  ContactType = new ContactType();
+  Addresses: Address[] = [];
+  Phones: Phone[] = [];
+}

package/src/tests/contact/ContactBase.ts

@@ -0,0 +1,8 @@
+import { Base } from "./Base.ts";
+
+export class ContactBase extends Base {
+  FirstName = "";
+  LastName = "";
+  Email: string | null = null;
+  Notes: string | null = null;
+}

package/src/tests/contact/ContactChangeLog.ts

@@ -0,0 +1,8 @@
+import { Base } from "./Base.ts";
+
+export class ContactChangeLog extends Base {
+  occurred_at = new Date(0);
+  contact_id = 0;
+  changed_by = "";
+  change_summary = "";
+}

package/src/tests/contact/ContactGroup.ts

@@ -0,0 +1,6 @@
+import { Contact } from "./Contact.ts";
+import { ContactGroupBase } from "./ContactGroupBase.ts";
+
+export class ContactGroup extends ContactGroupBase {
+  members: Contact[] = [];
+}

package/src/tests/contact/ContactGroupBase.ts

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

package/src/tests/contact/ContactGroupMember.ts

@@ -0,0 +1,6 @@
+import { Base } from "./Base.ts";
+
+export class ContactGroupMember extends Base {
+  contact_id = 0;
+  contact_group_id = 0;
+}

package/src/tests/contact/ContactSource.ts

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

package/src/tests/contact/ContactType.ts

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

package/src/tests/contact/ContactsService.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "../../collectAsync.ts";
+import { CRUDRepository } from "../../CRUDRepository.ts";
+import { ReadonlyRepository } from "../../ReadonlyRepository.ts";
+import type { Constructable } from "../../converters/Constructable.ts";
+import type { IConnection } from "../../IConnection.ts";
+import type { Scalar } from "../../builders/Scalar.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";
+
+describe("ContactsService", () => {
+  it("fills names and child lists", async () => {
+    const person: Record<string, Scalar> = { name: "person" };
+    const types = await setup([person]);
+    const typesRepo = createLookupRepo(ContactType, types);
+    const source: Record<string, Scalar> = { name: "import" };
+    const sources = await setup([source]);
+    const sourcesRepo = createLookupRepo(ContactSource, sources);
+    const home: Record<string, Scalar> = { name: "Home" };
+    const addressTypes = await setup([home]);
+    const addressTypesRepo = createLookupRepo(AddressType, addressTypes);
+    const work: Record<string, Scalar> = { name: "Work" };
+    const phoneTypes = await setup([work]);
+    const phoneTypesRepo = createLookupRepo(PhoneType, phoneTypes);
+    const connection = await setup();
+    const contactsRepo = new CRUDRepository(connection, {
+      type: Contact,
+      entityMapper: contactEntity,
+      propertyMappings: columns,
+      ids: ["Id"],
+    });
+    const addressesRepo = new CRUDRepository(connection, {
+      type: Address,
+      entityMapper: snake,
+      propertyMappings: columns,
+      ids: ["Id"],
+    });
+    const phonesRepo = new CRUDRepository(connection, {
+      type: Phone,
+      entityMapper: snake,
+      propertyMappings: columns,
+      ids: ["Id"],
+    });
+    const service = ContactsService.open(
+      contactsRepo,
+      typesRepo,
+      sourcesRepo,
+      addressTypesRepo,
+      phoneTypesRepo,
+      addressesRepo,
+      phonesRepo,
+    );
+    const other = await service.create(Object.assign(new Contact(), {
+      FirstName: "Other",
+      ContactType: Object.assign(new ContactType(), { Id: person.id }),
+      ContactSource: Object.assign(new ContactSource(), { Id: source.id }),
+    }));
+    expect(other.Id).toBeGreaterThan(0);
+    const stray = await addressesRepo.create(Object.assign(new Address(), {
+      Contact: Object.assign(new Contact(), { Id: other.Id }),
+      Line1: "other",
+      City: "x",
+      AddressType: Object.assign(new AddressType(), { Id: home.id }),
+    }));
+    expect(stray.Id).toBeGreaterThan(0);
+    const created = await service.create(Object.assign(new Contact(), {
+      ContactType: Object.assign(new ContactType(), { Id: person.id }),
+      ContactSource: Object.assign(new ContactSource(), { Id: source.id }),
+      FirstName: "Ada",
+      Addresses: [Object.assign(new Address(), {
+        Line1: "1 Main",
+        City: "Paris",
+        AddressType: Object.assign(new AddressType(), { Id: home.id }),
+      })],
+      Phones: [Object.assign(new Phone(), {
+        Number: "555",
+        PhoneType: Object.assign(new PhoneType(), { Id: work.id }),
+      })],
+    }));
+    expect(created.Id).toBeGreaterThan(0);
+    const contact = (await collectAsync(service.read())).find((item) => item.FirstName === "Ada");
+    expect(contact?.Id).toBe(created.Id);
+    expect(contact?.Id).not.toBe(other.Id);
+    expect(contact?.ContactType.Name).toBe("person");
+    expect(contact?.ContactSource.Name).toBe("import");
+    expect(contact?.Addresses).toHaveLength(1);
+    expect(contact?.Addresses[0]?.Id).toBeGreaterThan(0);
+    expect(contact?.Addresses[0]?.Line1).toBe("1 Main");
+    expect(contact?.Addresses[0]?.AddressType.Name).toBe("Home");
+    expect(contact?.Phones[0]?.Id).toBeGreaterThan(0);
+    expect(contact?.Phones[0]?.Number).toBe("555");
+    expect(contact?.Phones[0]?.PhoneType.Name).toBe("Work");
+  });
+});
+
+const createLookupRepo = <T extends object>(type: Constructable<T>, connection: IConnection) =>
+  new ReadonlyRepository(connection, { type, entityMapper: snake, propertyMappings: columns });
+
+const setup = async (rows: Record<string, Scalar>[] = []): Promise<IConnection> => {
+  const connection = new MemoryDriver().connection();
+  await connection.open();
+  for (const row of rows) {
+    const response = await connection.createCommand().execute(
+      "insert",
+      Object.entries(row).map(([name, value]) => ({ name, value })),
+    );
+    row.id = response.result as number;
+  }
+  return connection;
+};

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),
+  );
+};