@nest-yalc-2/omnikernel-module 2.2.2 → 2.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-yalc-2/omnikernel-module",
-  "version": "2.2.2",
+  "version": "2.2.6",
   "type": "module",
   "description": "Foundational OmniKernel persistence module for nestjs-yalc",
   "main": "./src/index.js",
@@ -16,32 +16,34 @@
     "src"
   ],
   "dependencies": {
-    "@nest-yalc-2/crud-gen": "^2.2.2",
-    "@nest-yalc-2/data-loader": "^2.2.2",
-    "@nest-yalc-2/event-manager": "^2.2.2",
-    "@nest-yalc-2/graphql": "^2.2.2",
-    "@nest-yalc-2/types": "^1.0.0",
-    "@nest-yalc-2/utils": "^2.2.2",
+    "@nest-yalc-2/crud-gen": "^2.2.6",
+    "@nest-yalc-2/data-loader": "^2.2.6",
+    "@nest-yalc-2/event-manager": "^2.2.6",
+    "@nest-yalc-2/graphql": "^2.2.6",
+    "@nest-yalc-2/types": "*",
+    "@nest-yalc-2/utils": "^2.2.6",
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@nestjs/common": "^11.1.19",
-    "@nestjs/core": "^11.1.19",
-    "@nestjs/event-emitter": "^3.0.1",
-    "@nestjs/graphql": "^13.2.5",
-    "@nestjs/typeorm": "^11.0.1",
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "@nestjs/event-emitter": "^12.0.0",
+    "@nestjs/graphql": "^14.0.0",
+    "@nestjs/typeorm": "^12.0.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.15.1",
-    "graphql": "^16.13.2",
+    "graphql": "^16.14.2",
     "graphql-type-json": "^0.3.2",
     "reflect-metadata": "^0.2.2",
-    "typeorm": "^0.3.28"
+    "typeorm": "^0.3.30"
   },
   "keywords": [
     "nestjs",
+    "nestjs-yalc",
     "yalc",
+    "omnikernel-module",
     "framework",
-    "omnikernel module"
+    "utility"
   ],
   "repository": {
     "type": "git",

package/src/__tests__/omni-collection.entity.spec.ts

@@ -1,49 +1,49 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniRecordEntity } from '../base/omni-record.entity.js';
-import { OmniCollectionEntity } from '../omni-collection.entity.js';
-import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
-
-describe('OmniCollectionEntity', () => {
-  it('extends OmniRecordEntity', () => {
-    expect(new OmniCollectionEntity()).toBeInstanceOf(OmniRecordEntity);
-  });
-
-  it('stores collections as child records in the omni-record table', () => {
-    const metadata = getMetadataArgsStorage();
-    const recordTable = metadata.tables.find(
-      (item) => item.target === OmniRecordEntity,
-    );
-    const collectionTable = metadata.tables.find(
-      (item) => item.target === OmniCollectionEntity,
-    );
-    const inheritance = metadata.inheritances.find(
-      (item) => item.target === OmniRecordEntity,
-    );
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniCollectionEntity)
-      .map((item) => item.propertyName);
-
-    expect(recordTable?.name).toBe('omni-record');
-    expect(collectionTable?.type).toBe('entity-child');
-    expect(inheritance?.column).toMatchObject({ name: 'recordType' });
-    expect(entityColumns).toEqual(
-      expect.arrayContaining(['collectionKind', 'summary']),
-    );
-  });
-
-  it('defaults the base record kind to collection in the class instance', () => {
-    const entity = new OmniCollectionEntity();
-
-    expect(entity.kind).toBe(OmniCollectionKind.Collection);
-  });
-
-  it('allows explicit collection subtypes while keeping the base record kind stable', () => {
-    const entity = new OmniCollectionEntity();
-    entity.collectionKind = OmniCollectionKind.Folder;
-
-    expect(entity.kind).toBe(OmniCollectionKind.Collection);
-    expect(entity.collectionKind).toBe(OmniCollectionKind.Folder);
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniRecordEntity } from '../base/omni-record.entity.js';
+import { OmniCollectionEntity } from '../omni-collection.entity.js';
+import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
+
+describe('OmniCollectionEntity', () => {
+  it('extends OmniRecordEntity', () => {
+    expect(new OmniCollectionEntity()).toBeInstanceOf(OmniRecordEntity);
+  });
+
+  it('stores collections as child records in the omni-record table', () => {
+    const metadata = getMetadataArgsStorage();
+    const recordTable = metadata.tables.find(
+      (item) => item.target === OmniRecordEntity,
+    );
+    const collectionTable = metadata.tables.find(
+      (item) => item.target === OmniCollectionEntity,
+    );
+    const inheritance = metadata.inheritances.find(
+      (item) => item.target === OmniRecordEntity,
+    );
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniCollectionEntity)
+      .map((item) => item.propertyName);
+
+    expect(recordTable?.name).toBe('omni-record');
+    expect(collectionTable?.type).toBe('entity-child');
+    expect(inheritance?.column).toMatchObject({ name: 'recordType' });
+    expect(entityColumns).toEqual(
+      expect.arrayContaining(['collectionKind', 'summary']),
+    );
+  });
+
+  it('defaults the base record kind to collection in the class instance', () => {
+    const entity = new OmniCollectionEntity();
+
+    expect(entity.kind).toBe(OmniCollectionKind.Collection);
+  });
+
+  it('allows explicit collection subtypes while keeping the base record kind stable', () => {
+    const entity = new OmniCollectionEntity();
+    entity.collectionKind = OmniCollectionKind.Folder;
+
+    expect(entity.kind).toBe(OmniCollectionKind.Collection);
+    expect(entity.collectionKind).toBe(OmniCollectionKind.Folder);
+  });
+});

package/src/__tests__/omni-collection.service.spec.ts

@@ -1,83 +1,83 @@
-import { describe, expect, it, jest } from '@jest/globals';
-
-import { OmniCollectionService } from '../omni-collection.service.js';
-import { OmniCollectionEntity } from '../omni-collection.entity.js';
-import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
-
-const createRepositoryPair = () => {
-  const readRepository = {
-    target: OmniCollectionEntity,
-    findOneOrFail: jest.fn(),
-    getId: jest.fn((entity: OmniCollectionEntity) => ({ guid: entity.guid })),
-  };
-  const writeRepository = {
-    target: OmniCollectionEntity,
-    create: jest.fn((input: unknown) => input),
-    insert: jest.fn(async () => ({
-      identifiers: [{ guid: 'aaaaaaaa-1111-1111-1111-111111111111' }],
-    })),
-    update: jest.fn(async () => ({ affected: 1 })),
-  };
-
-  return { readRepository, writeRepository };
-};
-
-describe('OmniCollectionService', () => {
-  it('forces the base record kind during createEntity', async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniCollectionService(
-      readRepository as never,
-      writeRepository as never,
-    );
-
-    await service.createEntity(
-      {
-        guid: 'aaaaaaaa-1111-1111-1111-111111111111',
-        title: 'Collection',
-        kind: 'unexpected-kind',
-        collectionKind: OmniCollectionKind.Folder,
-      },
-      undefined,
-      false,
-    );
-
-    expect(writeRepository.insert).toHaveBeenCalledWith(
-      expect.objectContaining({
-        kind: OmniCollectionKind.Collection,
-        collectionKind: OmniCollectionKind.Folder,
-      }),
-    );
-  });
-
-  it('forces the base record kind during updateEntity', async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniCollectionService(
-      readRepository as never,
-      writeRepository as never,
-    );
-    (service as any).validateConditions = jest.fn(async () => ({
-      guid: 'aaaaaaaa-1111-1111-1111-111111111111',
-    }));
-
-    await service.updateEntity(
-      { guid: 'aaaaaaaa-1111-1111-1111-111111111111' },
-      {
-        kind: 'unexpected-kind',
-        collectionKind: OmniCollectionKind.Folder,
-      },
-      undefined,
-      false,
-    );
-
-    expect(writeRepository.update).toHaveBeenCalledWith(
-      expect.objectContaining({
-        guid: 'aaaaaaaa-1111-1111-1111-111111111111',
-        kind: OmniCollectionKind.Collection,
-      }),
-      expect.objectContaining({
-        kind: OmniCollectionKind.Collection,
-        collectionKind: OmniCollectionKind.Folder,
-      }),
-    );
-  });
-});
+import { describe, expect, it, jest } from '@jest/globals';
+
+import { OmniCollectionService } from '../omni-collection.service.js';
+import { OmniCollectionEntity } from '../omni-collection.entity.js';
+import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
+
+const createRepositoryPair = () => {
+  const readRepository = {
+    target: OmniCollectionEntity,
+    findOneOrFail: jest.fn(),
+    getId: jest.fn((entity: OmniCollectionEntity) => ({ guid: entity.guid })),
+  };
+  const writeRepository = {
+    target: OmniCollectionEntity,
+    create: jest.fn((input: unknown) => input),
+    insert: jest.fn(async () => ({
+      identifiers: [{ guid: 'aaaaaaaa-1111-1111-1111-111111111111' }],
+    })),
+    update: jest.fn(async () => ({ affected: 1 })),
+  };
+
+  return { readRepository, writeRepository };
+};
+
+describe('OmniCollectionService', () => {
+  it('forces the base record kind during createEntity', async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniCollectionService(
+      readRepository as never,
+      writeRepository as never,
+    );
+
+    await service.createEntity(
+      {
+        guid: 'aaaaaaaa-1111-1111-1111-111111111111',
+        title: 'Collection',
+        kind: 'unexpected-kind',
+        collectionKind: OmniCollectionKind.Folder,
+      },
+      undefined,
+      false,
+    );
+
+    expect(writeRepository.insert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: OmniCollectionKind.Collection,
+        collectionKind: OmniCollectionKind.Folder,
+      }),
+    );
+  });
+
+  it('forces the base record kind during updateEntity', async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniCollectionService(
+      readRepository as never,
+      writeRepository as never,
+    );
+    (service as any).validateConditions = jest.fn(async () => ({
+      guid: 'aaaaaaaa-1111-1111-1111-111111111111',
+    }));
+
+    await service.updateEntity(
+      { guid: 'aaaaaaaa-1111-1111-1111-111111111111' },
+      {
+        kind: 'unexpected-kind',
+        collectionKind: OmniCollectionKind.Folder,
+      },
+      undefined,
+      false,
+    );
+
+    expect(writeRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        guid: 'aaaaaaaa-1111-1111-1111-111111111111',
+        kind: OmniCollectionKind.Collection,
+      }),
+      expect.objectContaining({
+        kind: OmniCollectionKind.Collection,
+        collectionKind: OmniCollectionKind.Folder,
+      }),
+    );
+  });
+});

package/src/__tests__/omni-document.entity.spec.ts

@@ -1,55 +1,55 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniRecordEntity } from '../base/omni-record.entity.js';
-import { OmniDocumentEntity } from '../omni-document.entity.js';
-import { OmniDocumentKind } from '../omni-document-kind.enum.js';
-
-describe('OmniDocumentEntity', () => {
-  it('extends OmniRecordEntity', () => {
-    expect(new OmniDocumentEntity()).toBeInstanceOf(OmniRecordEntity);
-  });
-
-  it('stores documents as child records in the omni-record table', () => {
-    const metadata = getMetadataArgsStorage();
-    const recordTable = metadata.tables.find(
-      (item) => item.target === OmniRecordEntity,
-    );
-    const documentTable = metadata.tables.find(
-      (item) => item.target === OmniDocumentEntity,
-    );
-    const inheritance = metadata.inheritances.find(
-      (item) => item.target === OmniRecordEntity,
-    );
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniDocumentEntity)
-      .map((item) => item.propertyName);
-
-    expect(recordTable?.name).toBe('omni-record');
-    expect(documentTable?.type).toBe('entity-child');
-    expect(inheritance?.column).toMatchObject({ name: 'recordType' });
-    expect(entityColumns).toEqual(
-      expect.arrayContaining([
-        'documentKind',
-        'content',
-        'contentMimeType',
-        'sourceUrl',
-        'publishedAt',
-      ]),
-    );
-  });
-
-  it('defaults the base record kind to document in the class instance', () => {
-    const entity = new OmniDocumentEntity();
-
-    expect(entity.kind).toBe(OmniDocumentKind.Document);
-  });
-
-  it('allows explicit document subtypes while keeping the base record kind stable', () => {
-    const entity = new OmniDocumentEntity();
-    entity.documentKind = OmniDocumentKind.Note;
-
-    expect(entity.kind).toBe(OmniDocumentKind.Document);
-    expect(entity.documentKind).toBe(OmniDocumentKind.Note);
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniRecordEntity } from '../base/omni-record.entity.js';
+import { OmniDocumentEntity } from '../omni-document.entity.js';
+import { OmniDocumentKind } from '../omni-document-kind.enum.js';
+
+describe('OmniDocumentEntity', () => {
+  it('extends OmniRecordEntity', () => {
+    expect(new OmniDocumentEntity()).toBeInstanceOf(OmniRecordEntity);
+  });
+
+  it('stores documents as child records in the omni-record table', () => {
+    const metadata = getMetadataArgsStorage();
+    const recordTable = metadata.tables.find(
+      (item) => item.target === OmniRecordEntity,
+    );
+    const documentTable = metadata.tables.find(
+      (item) => item.target === OmniDocumentEntity,
+    );
+    const inheritance = metadata.inheritances.find(
+      (item) => item.target === OmniRecordEntity,
+    );
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniDocumentEntity)
+      .map((item) => item.propertyName);
+
+    expect(recordTable?.name).toBe('omni-record');
+    expect(documentTable?.type).toBe('entity-child');
+    expect(inheritance?.column).toMatchObject({ name: 'recordType' });
+    expect(entityColumns).toEqual(
+      expect.arrayContaining([
+        'documentKind',
+        'content',
+        'contentMimeType',
+        'sourceUrl',
+        'publishedAt',
+      ]),
+    );
+  });
+
+  it('defaults the base record kind to document in the class instance', () => {
+    const entity = new OmniDocumentEntity();
+
+    expect(entity.kind).toBe(OmniDocumentKind.Document);
+  });
+
+  it('allows explicit document subtypes while keeping the base record kind stable', () => {
+    const entity = new OmniDocumentEntity();
+    entity.documentKind = OmniDocumentKind.Note;
+
+    expect(entity.kind).toBe(OmniDocumentKind.Document);
+    expect(entity.documentKind).toBe(OmniDocumentKind.Note);
+  });
+});

package/src/__tests__/omni-document.service.spec.ts

@@ -1,83 +1,83 @@
-import { describe, expect, it, jest } from '@jest/globals';
-
-import { OmniDocumentService } from '../omni-document.service.js';
-import { OmniDocumentEntity } from '../omni-document.entity.js';
-import { OmniDocumentKind } from '../omni-document-kind.enum.js';
-
-const createRepositoryPair = () => {
-  const readRepository = {
-    target: OmniDocumentEntity,
-    findOneOrFail: jest.fn(),
-    getId: jest.fn((entity: OmniDocumentEntity) => ({ guid: entity.guid })),
-  };
-  const writeRepository = {
-    target: OmniDocumentEntity,
-    create: jest.fn((input: unknown) => input),
-    insert: jest.fn(async () => ({
-      identifiers: [{ guid: '11111111-1111-1111-1111-111111111111' }],
-    })),
-    update: jest.fn(async () => ({ affected: 1 })),
-  };
-
-  return { readRepository, writeRepository };
-};
-
-describe('OmniDocumentService', () => {
-  it('forces the base record kind during createEntity', async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniDocumentService(
-      readRepository as never,
-      writeRepository as never,
-    );
-
-    await service.createEntity(
-      {
-        guid: '11111111-1111-1111-1111-111111111111',
-        title: 'Document',
-        kind: 'unexpected-kind',
-        documentKind: OmniDocumentKind.Note,
-      },
-      undefined,
-      false,
-    );
-
-    expect(writeRepository.insert).toHaveBeenCalledWith(
-      expect.objectContaining({
-        kind: OmniDocumentKind.Document,
-        documentKind: OmniDocumentKind.Note,
-      }),
-    );
-  });
-
-  it('forces the base record kind during updateEntity', async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniDocumentService(
-      readRepository as never,
-      writeRepository as never,
-    );
-    (service as any).validateConditions = jest.fn(async () => ({
-      guid: '11111111-1111-1111-1111-111111111111',
-    }));
-
-    await service.updateEntity(
-      { guid: '11111111-1111-1111-1111-111111111111' },
-      {
-        kind: 'unexpected-kind',
-        documentKind: OmniDocumentKind.Article,
-      },
-      undefined,
-      false,
-    );
-
-    expect(writeRepository.update).toHaveBeenCalledWith(
-      expect.objectContaining({
-        guid: '11111111-1111-1111-1111-111111111111',
-        kind: OmniDocumentKind.Document,
-      }),
-      expect.objectContaining({
-        kind: OmniDocumentKind.Document,
-        documentKind: OmniDocumentKind.Article,
-      }),
-    );
-  });
-});
+import { describe, expect, it, jest } from '@jest/globals';
+
+import { OmniDocumentService } from '../omni-document.service.js';
+import { OmniDocumentEntity } from '../omni-document.entity.js';
+import { OmniDocumentKind } from '../omni-document-kind.enum.js';
+
+const createRepositoryPair = () => {
+  const readRepository = {
+    target: OmniDocumentEntity,
+    findOneOrFail: jest.fn(),
+    getId: jest.fn((entity: OmniDocumentEntity) => ({ guid: entity.guid })),
+  };
+  const writeRepository = {
+    target: OmniDocumentEntity,
+    create: jest.fn((input: unknown) => input),
+    insert: jest.fn(async () => ({
+      identifiers: [{ guid: '11111111-1111-1111-1111-111111111111' }],
+    })),
+    update: jest.fn(async () => ({ affected: 1 })),
+  };
+
+  return { readRepository, writeRepository };
+};
+
+describe('OmniDocumentService', () => {
+  it('forces the base record kind during createEntity', async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniDocumentService(
+      readRepository as never,
+      writeRepository as never,
+    );
+
+    await service.createEntity(
+      {
+        guid: '11111111-1111-1111-1111-111111111111',
+        title: 'Document',
+        kind: 'unexpected-kind',
+        documentKind: OmniDocumentKind.Note,
+      },
+      undefined,
+      false,
+    );
+
+    expect(writeRepository.insert).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: OmniDocumentKind.Document,
+        documentKind: OmniDocumentKind.Note,
+      }),
+    );
+  });
+
+  it('forces the base record kind during updateEntity', async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniDocumentService(
+      readRepository as never,
+      writeRepository as never,
+    );
+    (service as any).validateConditions = jest.fn(async () => ({
+      guid: '11111111-1111-1111-1111-111111111111',
+    }));
+
+    await service.updateEntity(
+      { guid: '11111111-1111-1111-1111-111111111111' },
+      {
+        kind: 'unexpected-kind',
+        documentKind: OmniDocumentKind.Article,
+      },
+      undefined,
+      false,
+    );
+
+    expect(writeRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        guid: '11111111-1111-1111-1111-111111111111',
+        kind: OmniDocumentKind.Document,
+      }),
+      expect.objectContaining({
+        kind: OmniDocumentKind.Document,
+        documentKind: OmniDocumentKind.Article,
+      }),
+    );
+  });
+});