@productminds/article-events 2.0.1 → 3.0.0

package/lib/article-events/src/article-events.d.ts

@@ -0,0 +1,3 @@
+import ExternalArticleEvent from './events/ExternalArticleEvent';
+import InternalArticleEvent from './events/InternalArticleEvent';
+export { ExternalArticleEvent, InternalArticleEvent };

package/lib/article-events/src/article-events.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalArticleEvent = exports.ExternalArticleEvent = void 0;
+const ExternalArticleEvent_1 = __importDefault(require("./events/ExternalArticleEvent"));
+exports.ExternalArticleEvent = ExternalArticleEvent_1.default;
+const InternalArticleEvent_1 = __importDefault(require("./events/InternalArticleEvent"));
+exports.InternalArticleEvent = InternalArticleEvent_1.default;

package/lib/article-events/src/cmd/write-json-schema.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/article-events/src/cmd/write-json-schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@effect/schema");
+const InternalArticleEvent_1 = require("../events/InternalArticleEvent");
+const ExternalArticleEvent_1 = require("../events/ExternalArticleEvent");
+const fs_1 = require("fs");
+const dir = './jsonSchemas';
+if (!(0, fs_1.existsSync)(dir)) {
+    (0, fs_1.mkdirSync)(dir);
+}
+const jsonSchemaInternal = schema_1.JSONSchema.make(InternalArticleEvent_1.InternalArticleEventSchema);
+(0, fs_1.writeFileSync)(`${dir}/internalArticleEventSchema.json`, JSON.stringify(jsonSchemaInternal, null, 2));
+const jsonSchemaExternal = schema_1.JSONSchema.make(ExternalArticleEvent_1.ExternalArticleEventSchema);
+(0, fs_1.writeFileSync)(`${dir}/externalArticleEventSchema.json`, JSON.stringify(jsonSchemaExternal, null, 2));

package/lib/article-events/src/events/ExternalArticleEvent.d.ts

@@ -0,0 +1,418 @@
+import { Schema } from '@effect/schema';
+export declare const ExternalArticleEventSchema: Schema.Struct<{
+    kind: Schema.Literal<["EXTERNAL_ARTICLE_EVENT"]>;
+    payload: Schema.Struct<{
+        article: Schema.extend<Schema.Struct<{
+            id: typeof Schema.UUID;
+            title: typeof Schema.NonEmptyString;
+            teaser: typeof Schema.NonEmptyString;
+            content: typeof Schema.NonEmptyString;
+            publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            url: typeof Schema.NonEmptyString;
+            site: typeof Schema.NonEmptyString;
+            authors: Schema.Array$<Schema.Struct<{
+                name: typeof Schema.NonEmptyString;
+            }>>;
+        }>, Schema.Struct<{
+            tags: Schema.Array$<Schema.Struct<{
+                type: Schema.Literal<["CATEGORY"]>;
+                value: typeof Schema.NonEmptyString;
+            }>>;
+        }>>;
+        status: Schema.Literal<["NEW", "UPDATED"]>;
+        source: Schema.Literal<["EXTERNAL"]>;
+    }>;
+}>;
+declare const _default: {
+    decode: (u: unknown, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    decodeExn: (u: unknown) => {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    };
+    encode: (a: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
+        readonly kind: "EXTERNAL_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 authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    encodeExn: (event: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }) => {
+        readonly kind: "EXTERNAL_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 authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    };
+    fromString: (msg: string) => import("effect/Either").Either<{
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    fromBuffer: (msg: Buffer) => import("effect/Either").Either<{
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    fromStringExn: (msg: string) => {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    };
+    fromBufferExn: (msg: Buffer) => {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    };
+    toString: (event: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }) => string;
+    toBuffer: (event: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }) => Buffer;
+    toStringExn: (event: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }) => string;
+    toBufferExn: (event: {
+        readonly kind: "EXTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly id: string;
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly tags: readonly {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                }[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "EXTERNAL";
+        };
+    }) => Buffer;
+    Schema: Schema.Struct<{
+        kind: Schema.Literal<["EXTERNAL_ARTICLE_EVENT"]>;
+        payload: Schema.Struct<{
+            article: Schema.extend<Schema.Struct<{
+                id: typeof Schema.UUID;
+                title: typeof Schema.NonEmptyString;
+                teaser: typeof Schema.NonEmptyString;
+                content: typeof Schema.NonEmptyString;
+                publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                url: typeof Schema.NonEmptyString;
+                site: typeof Schema.NonEmptyString;
+                authors: Schema.Array$<Schema.Struct<{
+                    name: typeof Schema.NonEmptyString;
+                }>>;
+            }>, Schema.Struct<{
+                tags: Schema.Array$<Schema.Struct<{
+                    type: Schema.Literal<["CATEGORY"]>;
+                    value: typeof Schema.NonEmptyString;
+                }>>;
+            }>>;
+            status: Schema.Literal<["NEW", "UPDATED"]>;
+            source: Schema.Literal<["EXTERNAL"]>;
+        }>;
+    }>;
+};
+export default _default;

package/lib/article-events/src/events/ExternalArticleEvent.js

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

package/lib/article-events/src/events/InternalArticleEvent.d.ts

@@ -0,0 +1,546 @@
+import { Schema } from '@effect/schema';
+export declare const InternalArticleEventSchema: Schema.Struct<{
+    kind: Schema.Literal<["INTERNAL_ARTICLE_EVENT"]>;
+    payload: Schema.Struct<{
+        article: Schema.extend<Schema.extend<Schema.Struct<{
+            title: typeof Schema.NonEmptyString;
+            teaser: typeof Schema.NonEmptyString;
+            content: typeof Schema.NonEmptyString;
+            publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+            url: typeof Schema.NonEmptyString;
+            site: typeof Schema.NonEmptyString;
+            authors: Schema.Array$<Schema.Struct<{
+                name: typeof Schema.NonEmptyString;
+            }>>;
+        }>, Schema.Struct<{
+            id: typeof Schema.NonEmptyString;
+        }>>, Schema.Struct<{
+            tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                type: Schema.Literal<["CATEGORY"]>;
+                value: typeof Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                id: typeof Schema.UUID;
+            }>, Schema.Struct<{
+                type: Schema.Literal<["DRUPAL_EXTERNAL_ID"]>;
+                extID: typeof Schema.UUID;
+                extSource: typeof Schema.String;
+            }>]>>;
+        }>>;
+        status: Schema.Literal<["NEW", "UPDATED"]>;
+        source: Schema.Literal<["INTERNAL"]>;
+    }>;
+}>;
+declare const _default: {
+    decode: (u: unknown, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    decodeExn: (u: unknown) => {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    };
+    encode: (a: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }, overrideOptions?: import("@effect/schema/AST").ParseOptions) => import("effect/Either").Either<{
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                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 authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    encodeExn: (event: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }) => {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                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 authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    };
+    fromString: (msg: string) => import("effect/Either").Either<{
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    fromBuffer: (msg: Buffer) => import("effect/Either").Either<{
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }, import("@effect/schema/ParseResult").ParseError>;
+    fromStringExn: (msg: string) => {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    };
+    fromBufferExn: (msg: Buffer) => {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    };
+    toString: (event: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }) => string;
+    toBuffer: (event: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }) => Buffer;
+    toStringExn: (event: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }) => string;
+    toBufferExn: (event: {
+        readonly kind: "INTERNAL_ARTICLE_EVENT";
+        readonly payload: {
+            readonly article: {
+                readonly title: string;
+                readonly teaser: string;
+                readonly content: string;
+                readonly publishedAt: import("effect/DateTime").Utc;
+                readonly updatedAt: import("effect/DateTime").Utc;
+                readonly retrievedAt: import("effect/DateTime").Utc;
+                readonly url: string;
+                readonly site: string;
+                readonly authors: readonly {
+                    readonly name: string;
+                }[];
+            } & {
+                readonly id: string;
+            } & {
+                readonly tags: readonly ({
+                    readonly type: "DRUPAL_EXTERNAL_ID";
+                    readonly extID: string;
+                    readonly extSource: string;
+                } | {
+                    readonly type: "CATEGORY";
+                    readonly value: string;
+                } | {
+                    readonly type: "EXTERNAL_ARTICLE_REFERENCE";
+                    readonly id: string;
+                })[];
+            };
+            readonly status: "NEW" | "UPDATED";
+            readonly source: "INTERNAL";
+        };
+    }) => Buffer;
+    Schema: Schema.Struct<{
+        kind: Schema.Literal<["INTERNAL_ARTICLE_EVENT"]>;
+        payload: Schema.Struct<{
+            article: Schema.extend<Schema.extend<Schema.Struct<{
+                title: typeof Schema.NonEmptyString;
+                teaser: typeof Schema.NonEmptyString;
+                content: typeof Schema.NonEmptyString;
+                publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+                url: typeof Schema.NonEmptyString;
+                site: typeof Schema.NonEmptyString;
+                authors: Schema.Array$<Schema.Struct<{
+                    name: typeof Schema.NonEmptyString;
+                }>>;
+            }>, Schema.Struct<{
+                id: typeof Schema.NonEmptyString;
+            }>>, Schema.Struct<{
+                tags: Schema.Array$<Schema.Union<[Schema.Struct<{
+                    type: Schema.Literal<["CATEGORY"]>;
+                    value: typeof Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+                    id: typeof Schema.UUID;
+                }>, Schema.Struct<{
+                    type: Schema.Literal<["DRUPAL_EXTERNAL_ID"]>;
+                    extID: typeof Schema.UUID;
+                    extSource: typeof Schema.String;
+                }>]>>;
+            }>>;
+            status: Schema.Literal<["NEW", "UPDATED"]>;
+            source: Schema.Literal<["INTERNAL"]>;
+        }>;
+    }>;
+};
+export default _default;

package/lib/article-events/src/events/InternalArticleEvent.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalArticleEventSchema = void 0;
+const schema_1 = require("@effect/schema");
+const Article_1 = require("../types/Article");
+const makeHelpers_1 = require("../utils/makeHelpers");
+const InternalArticleSchema = schema_1.Schema.extend(Article_1.BaseInternalArticleSchema, schema_1.Schema.Struct({
+    tags: schema_1.Schema.Array(schema_1.Schema.Union(Article_1.CategoryTagSchema, Article_1.ExternalArticleReferenceTagSchema, Article_1.DrupalExternalIDTag)),
+}));
+exports.InternalArticleEventSchema = schema_1.Schema.Struct({
+    kind: schema_1.Schema.Literal('INTERNAL_ARTICLE_EVENT'),
+    payload: schema_1.Schema.Struct({
+        article: InternalArticleSchema,
+        status: schema_1.Schema.Literal('NEW', 'UPDATED'),
+        source: schema_1.Schema.Literal('INTERNAL'),
+    }),
+});
+const helpers = (0, makeHelpers_1.makeHelpers)(exports.InternalArticleEventSchema);
+exports.default = Object.assign({ Schema: exports.InternalArticleEventSchema }, helpers);

package/lib/article-events/src/types/Article.d.ts

@@ -0,0 +1,47 @@
+import { Schema } from '@effect/schema';
+export declare const DateTimeSchema: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+export declare const CategoryTagSchema: Schema.Struct<{
+    type: Schema.Literal<["CATEGORY"]>;
+    value: typeof Schema.NonEmptyString;
+}>;
+export declare const ExternalArticleReferenceTagSchema: Schema.Struct<{
+    type: Schema.Literal<["EXTERNAL_ARTICLE_REFERENCE"]>;
+    id: typeof Schema.UUID;
+}>;
+export declare const DrupalExternalIDTag: Schema.Struct<{
+    type: Schema.Literal<["DRUPAL_EXTERNAL_ID"]>;
+    extID: typeof Schema.UUID;
+    extSource: typeof Schema.String;
+}>;
+export declare const AuthorSchema: Schema.Struct<{
+    name: typeof Schema.NonEmptyString;
+}>;
+export declare const BaseArticleSchema: Schema.Struct<{
+    id: typeof Schema.UUID;
+    title: typeof Schema.NonEmptyString;
+    teaser: typeof Schema.NonEmptyString;
+    content: typeof Schema.NonEmptyString;
+    publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    url: typeof Schema.NonEmptyString;
+    site: typeof Schema.NonEmptyString;
+    authors: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.NonEmptyString;
+    }>>;
+}>;
+export declare const BaseInternalArticleSchema: Schema.extend<Schema.Struct<{
+    title: typeof Schema.NonEmptyString;
+    teaser: typeof Schema.NonEmptyString;
+    content: typeof Schema.NonEmptyString;
+    publishedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    updatedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    retrievedAt: Schema.transformOrFail<typeof Schema.String, typeof Schema.DateTimeUtcFromSelf, never>;
+    url: typeof Schema.NonEmptyString;
+    site: typeof Schema.NonEmptyString;
+    authors: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.NonEmptyString;
+    }>>;
+}>, Schema.Struct<{
+    id: typeof Schema.NonEmptyString;
+}>>;

package/lib/article-events/src/types/Article.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseInternalArticleSchema = exports.BaseArticleSchema = exports.AuthorSchema = exports.DrupalExternalIDTag = exports.ExternalArticleReferenceTagSchema = exports.CategoryTagSchema = exports.DateTimeSchema = void 0;
+const schema_1 = require("@effect/schema");
+const schema_2 = require("../../../shared/schema");
+exports.DateTimeSchema = schema_1.Schema.DateTimeUtc.annotations({
+    jsonSchema: { type: 'string', format: 'date-time' },
+});
+exports.CategoryTagSchema = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('CATEGORY'),
+    value: schema_1.Schema.NonEmptyString,
+});
+exports.ExternalArticleReferenceTagSchema = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('EXTERNAL_ARTICLE_REFERENCE'),
+    id: schema_1.Schema.UUID,
+});
+exports.DrupalExternalIDTag = schema_1.Schema.Struct({
+    type: schema_1.Schema.Literal('DRUPAL_EXTERNAL_ID'),
+    extID: schema_1.Schema.UUID,
+    extSource: schema_1.Schema.String,
+}).annotations({
+    description: 'A special case tag for tracking where a Drupal article was created from',
+});
+exports.AuthorSchema = schema_1.Schema.Struct({
+    name: schema_1.Schema.NonEmptyString,
+});
+exports.BaseArticleSchema = schema_1.Schema.Struct({
+    id: schema_1.Schema.UUID,
+    title: schema_1.Schema.NonEmptyString,
+    teaser: schema_1.Schema.NonEmptyString,
+    content: schema_1.Schema.NonEmptyString,
+    publishedAt: exports.DateTimeSchema,
+    updatedAt: exports.DateTimeSchema,
+    retrievedAt: exports.DateTimeSchema,
+    url: schema_1.Schema.NonEmptyString,
+    site: schema_1.Schema.NonEmptyString,
+    authors: schema_1.Schema.Array(exports.AuthorSchema),
+});
+exports.BaseInternalArticleSchema = schema_1.Schema.extend(exports.BaseArticleSchema.omit('id'), schema_1.Schema.Struct({
+    id: schema_2.InternalArticleIDSchema,
+}));

package/lib/article-events/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/lib/article-events/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/lib/shared/schema.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "@effect/schema";
+export declare const InternalArticleIDSchema: typeof Schema.NonEmptyString;

package/lib/shared/schema.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalArticleIDSchema = void 0;
+const schema_1 = require("@effect/schema");
+exports.InternalArticleIDSchema = schema_1.Schema.NonEmptyString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@productminds/article-events",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Article events",
   "license": "ISC",
   "main": "lib/article-events.js",