@productminds/article-events 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,316 +1,3 @@
-import { Schema } from '@effect/schema';
-export declare const ArticleSchema: Schema.Struct<{
-    id: typeof Schema.UUID;
-    title: typeof Schema.NonEmpty;
-    teaser: typeof Schema.NonEmpty;
-    content: typeof Schema.NonEmpty;
-    publishedAt: typeof Schema.Date;
-    updatedAt: typeof Schema.Date;
-    retrievedAt: typeof Schema.Date;
-    url: typeof Schema.NonEmpty;
-    site: typeof Schema.NonEmpty;
-    tags: Schema.Array$<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["category"]>;
-        value: typeof Schema.NonEmpty;
-    }>, Schema.Struct<{
-        type: Schema.Literal<["articleReference"]>;
-        id: typeof Schema.UUID;
-    }>]>>;
-    authors: Schema.Array$<Schema.Struct<{
-        name: typeof Schema.NonEmpty;
-    }>>;
-    meta: Schema.optional<typeof Schema.Unknown>;
-}>;
-export declare const ArticleEventSchema: Schema.Struct<{
-    kind: Schema.Literal<["ARTICLE_EVENT"]>;
-    payload: Schema.Struct<{
-        article: Schema.Struct<{
-            id: typeof Schema.UUID;
-            title: typeof Schema.NonEmpty;
-            teaser: typeof Schema.NonEmpty;
-            content: typeof Schema.NonEmpty;
-            publishedAt: typeof Schema.Date;
-            updatedAt: typeof Schema.Date;
-            retrievedAt: typeof Schema.Date;
-            url: typeof Schema.NonEmpty;
-            site: typeof Schema.NonEmpty;
-            tags: Schema.Array$<Schema.Union<[Schema.Struct<{
-                type: Schema.Literal<["category"]>;
-                value: typeof Schema.NonEmpty;
-            }>, Schema.Struct<{
-                type: Schema.Literal<["articleReference"]>;
-                id: typeof Schema.UUID;
-            }>]>>;
-            authors: Schema.Array$<Schema.Struct<{
-                name: typeof Schema.NonEmpty;
-            }>>;
-            meta: Schema.optional<typeof Schema.Unknown>;
-        }>;
-        status: Schema.Literal<["NEW", "UPDATED"]>;
-        source: Schema.Literal<["INTERNAL", "EXTERNAL"]>;
-    }>;
-}>;
-export declare const decode: (u: unknown, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-}, import("@effect/schema/ParseResult").ParseError>;
-export declare const decodeExn: (u: unknown) => {
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-};
-export declare const encode: (a: {
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-}, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: string;
-            readonly updatedAt: string;
-            readonly retrievedAt: string;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-}, import("@effect/schema/ParseResult").ParseError>;
-export declare const encodeExn: (event: typeof ArticleEventSchema.Type) => {
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: string;
-            readonly updatedAt: string;
-            readonly retrievedAt: string;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-};
-export declare const fromString: (msg: string) => import("effect/Either").Either<{
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-}, import("@effect/schema/ParseResult").ParseError>;
-export declare const fromBuffer: (msg: Buffer) => import("effect/Either").Either<{
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-}, import("@effect/schema/ParseResult").ParseError>;
-export declare const fromStringExn: (msg: string) => {
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-};
-export declare const fromBufferExn: (msg: Buffer) => {
-    readonly kind: "ARTICLE_EVENT";
-    readonly payload: {
-        readonly article: {
-            readonly id: string;
-            readonly title: string;
-            readonly teaser: string;
-            readonly content: string;
-            readonly publishedAt: Date;
-            readonly updatedAt: Date;
-            readonly retrievedAt: Date;
-            readonly url: string;
-            readonly site: string;
-            readonly tags: readonly ({
-                readonly type: "category";
-                readonly value: string;
-            } | {
-                readonly type: "articleReference";
-                readonly id: string;
-            })[];
-            readonly authors: readonly {
-                readonly name: string;
-            }[];
-            readonly meta?: unknown;
-        };
-        readonly status: "NEW" | "UPDATED";
-        readonly source: "INTERNAL" | "EXTERNAL";
-    };
-};
-export declare const toString: (event: typeof ArticleEventSchema.Type) => string;
-export declare const toBuffer: (event: typeof ArticleEventSchema.Type) => Buffer;
-export declare const toStringExn: (event: typeof ArticleEventSchema.Type) => string;
-export declare const toBufferExn: (event: typeof ArticleEventSchema.Type) => Buffer;
+export * from './src/events/ArticleEvent';
+export * from './src/events/ExternalArticleEvent';
+export * from './src/events/InternalArticleEvent';

package/dist/index.js

@@ -1,75 +1,19 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toBufferExn = exports.toStringExn = exports.toBuffer = exports.toString = exports.fromBufferExn = exports.fromStringExn = exports.fromBuffer = exports.fromString = exports.encodeExn = exports.encode = exports.decodeExn = exports.decode = exports.ArticleEventSchema = exports.ArticleSchema = void 0;
-const schema_1 = require("@effect/schema");
-const DateTimeSchema = schema_1.Schema.Date.annotations({
-    jsonSchema: { format: 'date-time' }
-});
-const CategoryTagSchema = schema_1.Schema.Struct({
-    type: schema_1.Schema.Literal('category'),
-    value: schema_1.Schema.NonEmpty
-});
-const ArticleReferenceSchema = schema_1.Schema.Struct({
-    type: schema_1.Schema.Literal('articleReference'),
-    id: schema_1.Schema.UUID
-});
-const TagSchema = schema_1.Schema.Union(CategoryTagSchema, ArticleReferenceSchema);
-const AuthorSchema = schema_1.Schema.Struct({
-    name: schema_1.Schema.NonEmpty
-});
-exports.ArticleSchema = schema_1.Schema.Struct({
-    id: schema_1.Schema.UUID,
-    title: schema_1.Schema.NonEmpty,
-    teaser: schema_1.Schema.NonEmpty,
-    content: schema_1.Schema.NonEmpty,
-    publishedAt: DateTimeSchema,
-    updatedAt: DateTimeSchema,
-    retrievedAt: DateTimeSchema,
-    url: schema_1.Schema.NonEmpty,
-    site: schema_1.Schema.NonEmpty,
-    tags: schema_1.Schema.Array(TagSchema),
-    authors: schema_1.Schema.Array(AuthorSchema),
-    meta: schema_1.Schema.optional(schema_1.Schema.Unknown)
-});
-exports.ArticleEventSchema = schema_1.Schema.Struct({
-    kind: schema_1.Schema.Literal('ARTICLE_EVENT'),
-    payload: schema_1.Schema.Struct({
-        article: exports.ArticleSchema,
-        status: schema_1.Schema.Literal('NEW', 'UPDATED'),
-        source: schema_1.Schema.Literal('INTERNAL', 'EXTERNAL')
-    })
-});
-exports.decode = schema_1.Schema.decodeUnknownEither(exports.ArticleEventSchema);
-const decodeExn = (u) => {
-    const decoded = (0, exports.decode)(u);
-    if (decoded._tag === 'Left') {
-        throw new Error('Failed to decode ArticleEvent');
-    }
-    return decoded.right;
-};
-exports.decodeExn = decodeExn;
-exports.encode = schema_1.Schema.encodeEither(exports.ArticleEventSchema);
-const encodeExn = (event) => {
-    const encoded = (0, exports.encode)(event);
-    if (encoded._tag === 'Left') {
-        throw new Error('Failed to encode ArticleEvent');
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    return encoded.right;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-exports.encodeExn = encodeExn;
-const fromString = (msg) => (0, exports.decode)(JSON.parse(msg));
-exports.fromString = fromString;
-const fromBuffer = (msg) => (0, exports.decode)(JSON.parse(msg.toString()));
-exports.fromBuffer = fromBuffer;
-const fromStringExn = (msg) => (0, exports.decodeExn)(JSON.parse(msg));
-exports.fromStringExn = fromStringExn;
-const fromBufferExn = (msg) => (0, exports.fromStringExn)(msg.toString());
-exports.fromBufferExn = fromBufferExn;
-const toString = (event) => JSON.stringify((0, exports.encode)(event));
-exports.toString = toString;
-const toBuffer = (event) => Buffer.from((0, exports.toString)(event));
-exports.toBuffer = toBuffer;
-const toStringExn = (event) => JSON.stringify((0, exports.encodeExn)(event));
-exports.toStringExn = toStringExn;
-const toBufferExn = (event) => Buffer.from((0, exports.toStringExn)(event));
-exports.toBufferExn = toBufferExn;
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/events/ArticleEvent"), exports);
+__exportStar(require("./src/events/ExternalArticleEvent"), exports);
+__exportStar(require("./src/events/InternalArticleEvent"), exports);

package/dist/src/events/ArticleEvent.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from '@effect/schema';
+export declare const ArticleEventSchema: Schema.Struct<{
+    kind: Schema.Literal<["ARTICLE_EVENT"]>;
+    payload: Schema.Struct<{
+        article: Schema.Struct<{
+            id: typeof Schema.UUID;
+            title: typeof Schema.NonEmpty;
+            teaser: typeof Schema.NonEmpty;
+            content: typeof Schema.NonEmpty;
+            publishedAt: typeof Schema.Date;
+            updatedAt: typeof Schema.Date;
+            retrievedAt: typeof Schema.Date;
+            url: typeof Schema.NonEmpty;
+            site: typeof Schema.NonEmpty;
+            tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                type: Schema.Literal<["CATEGORY"]>;
+                value: typeof Schema.NonEmpty;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                id: typeof Schema.UUID;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["ENTITY"]>;
+                entityType: Schema.Literal<["PERSON"]>;
+                value: typeof Schema.NonEmpty;
+            }>]>>;
+            authors: Schema.Array$<Schema.Struct<{
+                name: typeof Schema.NonEmpty;
+            }>>;
+            meta: Schema.optional<typeof Schema.Unknown>;
+        }>;
+        status: Schema.Literal<["NEW", "UPDATED"]>;
+        source: Schema.Literal<["INTERNAL", "EXTERNAL"]>;
+    }>;
+}>;
+declare const _default: {
+    Schema: Schema.Struct<{
+        kind: Schema.Literal<["ARTICLE_EVENT"]>;
+        payload: Schema.Struct<{
+            article: Schema.Struct<{
+                id: typeof Schema.UUID;
+                title: typeof Schema.NonEmpty;
+                teaser: typeof Schema.NonEmpty;
+                content: typeof Schema.NonEmpty;
+                publishedAt: typeof Schema.Date;
+                updatedAt: typeof Schema.Date;
+                retrievedAt: typeof Schema.Date;
+                url: typeof Schema.NonEmpty;
+                site: typeof Schema.NonEmpty;
+                tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    type: Schema.Literal<["CATEGORY"]>;
+                    value: typeof Schema.NonEmpty;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                    id: typeof Schema.UUID;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["ENTITY"]>;
+                    entityType: Schema.Literal<["PERSON"]>;
+                    value: typeof Schema.NonEmpty;
+                }>]>>;
+                authors: Schema.Array$<Schema.Struct<{
+                    name: typeof Schema.NonEmpty;
+                }>>;
+                meta: Schema.optional<typeof Schema.Unknown>;
+            }>;
+            status: Schema.Literal<["NEW", "UPDATED"]>;
+            source: Schema.Literal<["INTERNAL", "EXTERNAL"]>;
+        }>;
+    }>;
+};
+export default _default;

package/dist/src/events/ArticleEvent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArticleEventSchema = void 0;
+const schema_1 = require("@effect/schema");
+const Article_1 = require("../types/Article");
+exports.ArticleEventSchema = schema_1.Schema.Struct({
+    kind: schema_1.Schema.Literal('ARTICLE_EVENT'),
+    payload: schema_1.Schema.Struct({
+        article: Article_1.ArticleSchema,
+        status: schema_1.Schema.Literal('NEW', 'UPDATED'),
+        source: schema_1.Schema.Literal('INTERNAL', 'EXTERNAL')
+    })
+});
+const makeHelpers_1 = require("../utils/makeHelpers");
+const helpers = (0, makeHelpers_1.makeHelpers)(exports.ArticleEventSchema);
+exports.default = Object.assign({ Schema: exports.ArticleEventSchema }, makeHelpers_1.makeHelpers);

package/dist/src/events/ExternalArticleEvent.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from '@effect/schema';
+export declare const ExternalArticleEventSchema: Schema.Struct<{
+    kind: Schema.Literal<["EXTERNAL_ARTICLE_EVENT"]>;
+    payload: Schema.Struct<{
+        article: Schema.Struct<{
+            id: typeof Schema.UUID;
+            title: typeof Schema.NonEmpty;
+            teaser: typeof Schema.NonEmpty;
+            content: typeof Schema.NonEmpty;
+            publishedAt: typeof Schema.Date;
+            updatedAt: typeof Schema.Date;
+            retrievedAt: typeof Schema.Date;
+            url: typeof Schema.NonEmpty;
+            site: typeof Schema.NonEmpty;
+            tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                type: Schema.Literal<["CATEGORY"]>;
+                value: typeof Schema.NonEmpty;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                id: typeof Schema.UUID;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["ENTITY"]>;
+                entityType: Schema.Literal<["PERSON"]>;
+                value: typeof Schema.NonEmpty;
+            }>]>>;
+            authors: Schema.Array$<Schema.Struct<{
+                name: typeof Schema.NonEmpty;
+            }>>;
+            meta: Schema.optional<typeof Schema.Unknown>;
+        }>;
+        status: Schema.Literal<["NEW", "UPDATED"]>;
+        source: Schema.Literal<["EXTERNAL"]>;
+    }>;
+}>;
+declare const _default: {
+    Schema: Schema.Struct<{
+        kind: Schema.Literal<["EXTERNAL_ARTICLE_EVENT"]>;
+        payload: Schema.Struct<{
+            article: Schema.Struct<{
+                id: typeof Schema.UUID;
+                title: typeof Schema.NonEmpty;
+                teaser: typeof Schema.NonEmpty;
+                content: typeof Schema.NonEmpty;
+                publishedAt: typeof Schema.Date;
+                updatedAt: typeof Schema.Date;
+                retrievedAt: typeof Schema.Date;
+                url: typeof Schema.NonEmpty;
+                site: typeof Schema.NonEmpty;
+                tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    type: Schema.Literal<["CATEGORY"]>;
+                    value: typeof Schema.NonEmpty;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                    id: typeof Schema.UUID;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["ENTITY"]>;
+                    entityType: Schema.Literal<["PERSON"]>;
+                    value: typeof Schema.NonEmpty;
+                }>]>>;
+                authors: Schema.Array$<Schema.Struct<{
+                    name: typeof Schema.NonEmpty;
+                }>>;
+                meta: Schema.optional<typeof Schema.Unknown>;
+            }>;
+            status: Schema.Literal<["NEW", "UPDATED"]>;
+            source: Schema.Literal<["EXTERNAL"]>;
+        }>;
+    }>;
+};
+export default _default;

package/dist/src/events/ExternalArticleEvent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalArticleEventSchema = void 0;
+const schema_1 = require("@effect/schema");
+const Article_1 = require("../types/Article");
+exports.ExternalArticleEventSchema = schema_1.Schema.Struct({
+    kind: schema_1.Schema.Literal('EXTERNAL_ARTICLE_EVENT'),
+    payload: schema_1.Schema.Struct({
+        article: Article_1.ArticleSchema,
+        status: schema_1.Schema.Literal('NEW', 'UPDATED'),
+        source: schema_1.Schema.Literal('EXTERNAL')
+    })
+});
+const makeHelpers_1 = require("../utils/makeHelpers");
+const helpers = (0, makeHelpers_1.makeHelpers)(exports.ExternalArticleEventSchema);
+exports.default = Object.assign({ Schema: exports.ExternalArticleEventSchema }, makeHelpers_1.makeHelpers);

package/dist/src/events/InternalArticleEvent.d.ts

@@ -0,0 +1,70 @@
+import { Schema } from '@effect/schema';
+export declare const InternalArticleEvent: Schema.Struct<{
+    kind: Schema.Literal<["INTERNAL_ARTICLE_EVENT"]>;
+    payload: Schema.Struct<{
+        article: Schema.Struct<{
+            id: typeof Schema.UUID;
+            title: typeof Schema.NonEmpty;
+            teaser: typeof Schema.NonEmpty;
+            content: typeof Schema.NonEmpty;
+            publishedAt: typeof Schema.Date;
+            updatedAt: typeof Schema.Date;
+            retrievedAt: typeof Schema.Date;
+            url: typeof Schema.NonEmpty;
+            site: typeof Schema.NonEmpty;
+            tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                type: Schema.Literal<["CATEGORY"]>;
+                value: typeof Schema.NonEmpty;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                id: typeof Schema.UUID;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["ENTITY"]>;
+                entityType: Schema.Literal<["PERSON"]>;
+                value: typeof Schema.NonEmpty;
+            }>]>>;
+            authors: Schema.Array$<Schema.Struct<{
+                name: typeof Schema.NonEmpty;
+            }>>;
+            meta: Schema.optional<typeof Schema.Unknown>;
+        }>;
+        status: Schema.Literal<["NEW", "UPDATED"]>;
+        source: Schema.Literal<["INTERNAL"]>;
+    }>;
+}>;
+declare const _default: {
+    Schema: Schema.Struct<{
+        kind: Schema.Literal<["INTERNAL_ARTICLE_EVENT"]>;
+        payload: Schema.Struct<{
+            article: Schema.Struct<{
+                id: typeof Schema.UUID;
+                title: typeof Schema.NonEmpty;
+                teaser: typeof Schema.NonEmpty;
+                content: typeof Schema.NonEmpty;
+                publishedAt: typeof Schema.Date;
+                updatedAt: typeof Schema.Date;
+                retrievedAt: typeof Schema.Date;
+                url: typeof Schema.NonEmpty;
+                site: typeof Schema.NonEmpty;
+                tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    type: Schema.Literal<["CATEGORY"]>;
+                    value: typeof Schema.NonEmpty;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                    id: typeof Schema.UUID;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["ENTITY"]>;
+                    entityType: Schema.Literal<["PERSON"]>;
+                    value: typeof Schema.NonEmpty;
+                }>]>>;
+                authors: Schema.Array$<Schema.Struct<{
+                    name: typeof Schema.NonEmpty;
+                }>>;
+                meta: Schema.optional<typeof Schema.Unknown>;
+            }>;
+            status: Schema.Literal<["NEW", "UPDATED"]>;
+            source: Schema.Literal<["INTERNAL"]>;
+        }>;
+    }>;
+};
+export default _default;

package/dist/src/events/InternalArticleEvent.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalArticleEvent = void 0;
+const schema_1 = require("@effect/schema");
+const Article_1 = require("../types/Article");
+exports.InternalArticleEvent = schema_1.Schema.Struct({
+    kind: schema_1.Schema.Literal('INTERNAL_ARTICLE_EVENT'),
+    payload: schema_1.Schema.Struct({
+        article: Article_1.ArticleSchema,
+        status: schema_1.Schema.Literal('NEW', 'UPDATED'),
+        source: schema_1.Schema.Literal('INTERNAL')
+    })
+});
+const makeHelpers_1 = require("../utils/makeHelpers");
+const helpers = (0, makeHelpers_1.makeHelpers)(exports.InternalArticleEvent);
+exports.default = Object.assign({ Schema: exports.InternalArticleEvent }, makeHelpers_1.makeHelpers);

package/dist/src/types/Article.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from '@effect/schema';
+export declare const DateTimeSchema: typeof Schema.Date;
+export declare const CategoryTagSchema: Schema.Struct<{
+    type: Schema.Literal<["CATEGORY"]>;
+    value: typeof Schema.NonEmpty;
+}>;
+export declare const ArticleReferenceSchema: Schema.Struct<{
+    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+    id: typeof Schema.UUID;
+}>;
+export declare const EntityTag: Schema.Struct<{
+    type: Schema.Literal<["ENTITY"]>;
+    entityType: Schema.Literal<["PERSON"]>;
+    value: typeof Schema.NonEmpty;
+}>;
+export declare const TagSchema: Schema.Union<[Schema.Struct<{
+    type: Schema.Literal<["CATEGORY"]>;
+    value: typeof Schema.NonEmpty;
+}>, Schema.Struct<{
+    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+    id: typeof Schema.UUID;
+}>, Schema.Struct<{
+    type: Schema.Literal<["ENTITY"]>;
+    entityType: Schema.Literal<["PERSON"]>;
+    value: typeof Schema.NonEmpty;
+}>]>;
+export declare const AuthorSchema: Schema.Struct<{
+    name: typeof Schema.NonEmpty;
+}>;
+export declare const ArticleSchema: Schema.Struct<{
+    id: typeof Schema.UUID;
+    title: typeof Schema.NonEmpty;
+    teaser: typeof Schema.NonEmpty;
+    content: typeof Schema.NonEmpty;
+    publishedAt: typeof Schema.Date;
+    updatedAt: typeof Schema.Date;
+    retrievedAt: typeof Schema.Date;
+    url: typeof Schema.NonEmpty;
+    site: typeof Schema.NonEmpty;
+    tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+        type: Schema.Literal<["CATEGORY"]>;
+        value: typeof Schema.NonEmpty;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+        id: typeof Schema.UUID;
+    }>, Schema.Struct<{
+        type: Schema.Literal<["ENTITY"]>;
+        entityType: Schema.Literal<["PERSON"]>;
+        value: typeof Schema.NonEmpty;
+    }>]>>;
+    authors: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.NonEmpty;
+    }>>;
+    meta: Schema.optional<typeof Schema.Unknown>;
+}>;

package/dist/src/types/Article.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArticleSchema = exports.AuthorSchema = exports.TagSchema = exports.EntityTag = exports.ArticleReferenceSchema = exports.CategoryTagSchema = exports.DateTimeSchema = void 0;
+const schema_1 = require("@effect/schema");
+exports.DateTimeSchema = schema_1.Schema.Date.annotations({
+    jsonSchema: { format: 'date-time' }
+});
+exports.CategoryTagSchema = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('CATEGORY'),
+    value: schema_1.Schema.NonEmpty
+});
+exports.ArticleReferenceSchema = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('EXTERNAL_ARTICLE_REFERENCE'),
+    id: schema_1.Schema.UUID
+});
+exports.EntityTag = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('ENTITY'),
+    entityType: schema_1.Schema.Literal('PERSON'),
+    value: schema_1.Schema.NonEmpty
+});
+exports.TagSchema = schema_1.Schema.Union(exports.CategoryTagSchema, exports.ArticleReferenceSchema, exports.EntityTag);
+exports.AuthorSchema = schema_1.Schema.Struct({
+    name: schema_1.Schema.NonEmpty
+});
+exports.ArticleSchema = schema_1.Schema.Struct({
+    id: schema_1.Schema.UUID,
+    title: schema_1.Schema.NonEmpty,
+    teaser: schema_1.Schema.NonEmpty,
+    content: schema_1.Schema.NonEmpty,
+    publishedAt: exports.DateTimeSchema,
+    updatedAt: exports.DateTimeSchema,
+    retrievedAt: exports.DateTimeSchema,
+    url: schema_1.Schema.NonEmpty,
+    site: schema_1.Schema.NonEmpty,
+    tags: schema_1.Schema.Array(exports.TagSchema),
+    authors: schema_1.Schema.Array(exports.AuthorSchema),
+    meta: schema_1.Schema.optional(schema_1.Schema.Unknown)
+});

package/dist/src/utils/makeHelpers.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from '@effect/schema';
+export declare const makeHelpers: <A, I>(schema: Schema.Schema<A, I, never>) => {
+    decode: (u: unknown, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<A, import("@effect/schema/ParseResult").ParseError>;
+    decodeExn: (u: unknown) => A;
+    encode: (a: A, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<I, import("@effect/schema/ParseResult").ParseError>;
+    encodeExn: (event: typeof schema.Type) => I;
+    fromString: (msg: string) => import("effect/Either").Either<A, import("@effect/schema/ParseResult").ParseError>;
+    fromBuffer: (msg: Buffer) => import("effect/Either").Either<A, import("@effect/schema/ParseResult").ParseError>;
+    fromStringExn: (msg: string) => A;
+    fromBufferExn: (msg: Buffer) => A;
+    toString: (event: typeof schema.Type) => string;
+    toBuffer: (event: typeof schema.Type) => Buffer;
+    toStringExn: (event: typeof schema.Type) => string;
+    toBufferExn: (event: typeof schema.Type) => Buffer;
+};

package/dist/src/utils/makeHelpers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHelpers = void 0;
+const schema_1 = require("@effect/schema");
+const makeHelpers = (schema) => {
+    const decode = schema_1.Schema.decodeUnknownEither(schema);
+    const decodeExn = (u) => {
+        const decoded = decode(u);
+        if (decoded._tag === 'Left') {
+            throw new Error('Failed to decode ArticleEvent');
+        }
+        return decoded.right;
+    };
+    const encode = schema_1.Schema.encodeEither(schema);
+    const encodeExn = (event) => {
+        const encoded = encode(event);
+        if (encoded._tag === 'Left') {
+            throw new Error('Failed to encode ArticleEvent');
+        }
+        return encoded.right;
+    };
+    const fromString = (msg) => decode(JSON.parse(msg));
+    const fromBuffer = (msg) => decode(JSON.parse(msg.toString()));
+    const fromStringExn = (msg) => decodeExn(JSON.parse(msg));
+    const fromBufferExn = (msg) => fromStringExn(msg.toString());
+    const toString = (event) => JSON.stringify(encode(event));
+    const toBuffer = (event) => Buffer.from(toString(event));
+    const toStringExn = (event) => JSON.stringify(encodeExn(event));
+    const toBufferExn = (event) => Buffer.from(toStringExn(event));
+    return {
+        decode,
+        decodeExn,
+        encode,
+        encodeExn,
+        fromString,
+        fromBuffer,
+        fromStringExn,
+        fromBufferExn,
+        toString,
+        toBuffer,
+        toStringExn,
+        toBufferExn
+    };
+};
+exports.makeHelpers = makeHelpers;

package/index.ts

@@ -1,84 +1,3 @@
-import { Schema } from '@effect/schema';
-
-const DateTimeSchema = Schema.Date.annotations({
-  jsonSchema: { format: 'date-time' }
-});
-
-const CategoryTagSchema = Schema.Struct({
-  type: Schema.Literal('category'),
-  value: Schema.NonEmpty
-});
-
-const ArticleReferenceSchema = Schema.Struct({
-  type: Schema.Literal('articleReference'),
-  id: Schema.UUID
-});
-
-const TagSchema = Schema.Union(CategoryTagSchema, ArticleReferenceSchema);
-
-const AuthorSchema = Schema.Struct({
-  name: Schema.NonEmpty
-});
-
-export const ArticleSchema = Schema.Struct({
-  id: Schema.UUID,
-  title: Schema.NonEmpty,
-  teaser: Schema.NonEmpty,
-  content: Schema.NonEmpty,
-  publishedAt: DateTimeSchema,
-  updatedAt: DateTimeSchema,
-  retrievedAt: DateTimeSchema,
-  url: Schema.NonEmpty,
-  site: Schema.NonEmpty,
-  tags: Schema.Array(TagSchema),
-  authors: Schema.Array(AuthorSchema),
-  meta: Schema.optional(Schema.Unknown)
-});
-
-export const ArticleEventSchema = Schema.Struct({
-  kind: Schema.Literal('ARTICLE_EVENT'),
-  payload: Schema.Struct({
-    article: ArticleSchema,
-    status: Schema.Literal('NEW', 'UPDATED'),
-    source: Schema.Literal('INTERNAL', 'EXTERNAL')
-  })
-});
-
-export const decode = Schema.decodeUnknownEither(ArticleEventSchema);
-export const decodeExn = (u: unknown) => {
-  const decoded = decode(u);
-
-  if (decoded._tag === 'Left') {
-    throw new Error('Failed to decode ArticleEvent');
-  }
-
-  return decoded.right;
-};
-
-export const encode = Schema.encodeEither(ArticleEventSchema);
-export const encodeExn = (event: typeof ArticleEventSchema.Type) => {
-  const encoded = encode(event);
-
-  if (encoded._tag === 'Left') {
-    throw new Error('Failed to encode ArticleEvent');
-  }
-
-  return encoded.right;
-};
-
-export const fromString = (msg: string) => decode(JSON.parse(msg));
-export const fromBuffer = (msg: Buffer) => decode(JSON.parse(msg.toString()));
-
-export const fromStringExn = (msg: string) => decodeExn(JSON.parse(msg));
-export const fromBufferExn = (msg: Buffer) => fromStringExn(msg.toString());
-
-export const toString = (event: typeof ArticleEventSchema.Type) =>
-  JSON.stringify(encode(event));
-
-export const toBuffer = (event: typeof ArticleEventSchema.Type) =>
-  Buffer.from(toString(event));
-
-export const toStringExn = (event: typeof ArticleEventSchema.Type) =>
-  JSON.stringify(encodeExn(event));
-export const toBufferExn = (event: typeof ArticleEventSchema.Type) =>
-  Buffer.from(toStringExn(event));
+export * from './src/events/ArticleEvent';
+export * from './src/events/ExternalArticleEvent';
+export * from './src/events/InternalArticleEvent';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@productminds/article-events",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/events/ArticleEvent.ts

@@ -0,0 +1,19 @@
+import { Schema } from '@effect/schema';
+import { ArticleSchema } from '../types/Article';
+
+export const ArticleEventSchema = Schema.Struct({
+  kind: Schema.Literal('ARTICLE_EVENT'),
+  payload: Schema.Struct({
+    article: ArticleSchema,
+    status: Schema.Literal('NEW', 'UPDATED'),
+    source: Schema.Literal('INTERNAL', 'EXTERNAL')
+  })
+});
+
+import { makeHelpers } from '../utils/makeHelpers';
+const helpers = makeHelpers(ArticleEventSchema);
+
+export default {
+  Schema: ArticleEventSchema,
+  ...makeHelpers
+};

package/src/events/ExternalArticleEvent.ts

@@ -0,0 +1,19 @@
+import { Schema } from '@effect/schema';
+import { ArticleSchema } from '../types/Article';
+
+export const ExternalArticleEventSchema = Schema.Struct({
+  kind: Schema.Literal('EXTERNAL_ARTICLE_EVENT'),
+  payload: Schema.Struct({
+    article: ArticleSchema,
+    status: Schema.Literal('NEW', 'UPDATED'),
+    source: Schema.Literal('EXTERNAL')
+  })
+});
+
+import { makeHelpers } from '../utils/makeHelpers';
+const helpers = makeHelpers(ExternalArticleEventSchema);
+
+export default {
+  Schema: ExternalArticleEventSchema,
+  ...makeHelpers
+};

package/src/events/InternalArticleEvent.ts

@@ -0,0 +1,19 @@
+import { Schema } from '@effect/schema';
+import { ArticleSchema } from '../types/Article';
+
+export const InternalArticleEvent = Schema.Struct({
+  kind: Schema.Literal('INTERNAL_ARTICLE_EVENT'),
+  payload: Schema.Struct({
+    article: ArticleSchema,
+    status: Schema.Literal('NEW', 'UPDATED'),
+    source: Schema.Literal('INTERNAL')
+  })
+});
+
+import { makeHelpers } from '../utils/makeHelpers';
+const helpers = makeHelpers(InternalArticleEvent);
+
+export default {
+  Schema: InternalArticleEvent,
+  ...makeHelpers
+};

package/src/types/Article.ts

@@ -0,0 +1,46 @@
+import { Schema } from '@effect/schema';
+
+export const DateTimeSchema = Schema.Date.annotations({
+  jsonSchema: { format: 'date-time' }
+});
+
+export const CategoryTagSchema = Schema.Struct({
+  type: Schema.Literal('CATEGORY'),
+  value: Schema.NonEmpty
+});
+
+export const ArticleReferenceSchema = Schema.Struct({
+  type: Schema.Literal('EXTERNAL_ARTICLE_REFERENCE'),
+  id: Schema.UUID
+});
+
+export const EntityTag = Schema.Struct({
+  type: Schema.Literal('ENTITY'),
+  entityType: Schema.Literal('PERSON'),
+  value: Schema.NonEmpty
+});
+
+export const TagSchema = Schema.Union(
+  CategoryTagSchema,
+  ArticleReferenceSchema,
+  EntityTag
+);
+
+export const AuthorSchema = Schema.Struct({
+  name: Schema.NonEmpty
+});
+
+export const ArticleSchema = Schema.Struct({
+  id: Schema.UUID,
+  title: Schema.NonEmpty,
+  teaser: Schema.NonEmpty,
+  content: Schema.NonEmpty,
+  publishedAt: DateTimeSchema,
+  updatedAt: DateTimeSchema,
+  retrievedAt: DateTimeSchema,
+  url: Schema.NonEmpty,
+  site: Schema.NonEmpty,
+  tags: Schema.Array(TagSchema),
+  authors: Schema.Array(AuthorSchema),
+  meta: Schema.optional(Schema.Unknown)
+});

package/src/utils/makeHelpers.ts

@@ -0,0 +1,55 @@
+import { Schema } from '@effect/schema';
+
+export const makeHelpers = <A, I>(schema: Schema.Schema<A, I, never>) => {
+  const decode = Schema.decodeUnknownEither(schema);
+  const decodeExn = (u: unknown) => {
+    const decoded = decode(u);
+
+    if (decoded._tag === 'Left') {
+      throw new Error('Failed to decode ArticleEvent');
+    }
+
+    return decoded.right;
+  };
+
+  const encode = Schema.encodeEither(schema);
+  const encodeExn = (event: typeof schema.Type) => {
+    const encoded = encode(event);
+
+    if (encoded._tag === 'Left') {
+      throw new Error('Failed to encode ArticleEvent');
+    }
+
+    return encoded.right;
+  };
+
+  const fromString = (msg: string) => decode(JSON.parse(msg));
+  const fromBuffer = (msg: Buffer) => decode(JSON.parse(msg.toString()));
+
+  const fromStringExn = (msg: string) => decodeExn(JSON.parse(msg));
+  const fromBufferExn = (msg: Buffer) => fromStringExn(msg.toString());
+
+  const toString = (event: typeof schema.Type) => JSON.stringify(encode(event));
+
+  const toBuffer = (event: typeof schema.Type) => Buffer.from(toString(event));
+
+  const toStringExn = (event: typeof schema.Type) =>
+    JSON.stringify(encodeExn(event));
+  const toBufferExn = (event: typeof schema.Type) =>
+    Buffer.from(toStringExn(event));
+
+  return {
+    decode,
+    decodeExn,
+    encode,
+    encodeExn,
+    fromString,
+    fromBuffer,
+    fromStringExn,
+    fromBufferExn,
+    toString,
+    toBuffer,
+    toStringExn,
+    toBufferExn
+  };
+};