sitero-server 0.0.1

package/dist/src/application/resources/post/operations/queries/find-list-cards/validation/schema.js

@@ -0,0 +1,34 @@
+import { POST_TYPES } from 'sitero-domain';
+import { z } from 'zod';
+import { idSchema, textSchema, requiredTextSchema } from '../../../../../../conventions/validation/schema.js';
+
+const postFindListCardsInputSchema = () => z.object({
+  locale: requiredTextSchema(),
+  searchString: textSchema().optional(),
+  type: z.enum(POST_TYPES).optional(),
+  isActive: z.boolean().optional(),
+  isIndexActive: z.boolean().optional(),
+  isSlugActive: z.boolean().optional(),
+  isFeatured: z.boolean().optional(),
+  isShownOnHome: z.boolean().optional(),
+  state1: z.boolean().optional(),
+  state2: z.boolean().optional(),
+  state3: z.boolean().optional(),
+  state4: z.boolean().optional(),
+  state5: z.boolean().optional(),
+  state6: z.boolean().optional(),
+  state7: z.boolean().optional(),
+  state8: z.boolean().optional(),
+  state9: z.boolean().optional(),
+  state10: z.boolean().optional(),
+  topicId: idSchema().nullable().optional(),
+  topicSlug: textSchema().optional(),
+  parentId: idSchema().optional(),
+  parentSlug: textSchema().optional(),
+  postIds: z.array(idSchema()).optional(),
+  excludeIds: z.array(idSchema()).optional(),
+  page: z.number().int().positive().optional(),
+  pageSize: z.number().int().positive().optional()
+});
+
+export { postFindListCardsInputSchema };

package/dist/src/application/resources/post/operations/queries/find-list-cards/validation/validate-input.js

@@ -0,0 +1,13 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { postFindListCardsInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const validatedInput = postFindListCardsInputSchema().parse(input);
+  return {
+    ...validatedInput,
+    ...validatedInput.postIds ? { postIds: normalizeStringSelection(validatedInput.postIds) } : {},
+    ...validatedInput.excludeIds ? { excludeIds: normalizeStringSelection(validatedInput.excludeIds) } : {}
+  };
+}
+
+export { validateInput };

package/dist/src/application/resources/post/operations/queries/find-many/cache.js

@@ -0,0 +1,25 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createResourceTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createPostFindManyCacheKey = (input) => createCacheKey("post", "find-many", {
+  type: input?.type,
+  topicId: input?.topicId,
+  postIds: normalizeSelection(input?.postIds)
+});
+const createPostFindManyCacheTags = (input, result) => {
+  if (input?.postIds?.length === 0) {
+    return [];
+  }
+  return [
+    ...new Set(
+      [
+        createResourceTag("post"),
+        ...result.data.posts.flatMap((post) => [
+          createResourceTag("post", { id: post.id })
+        ])
+      ].flat()
+    )
+  ];
+};
+
+export { createPostFindManyCacheKey, createPostFindManyCacheTags };

package/dist/src/application/resources/post/operations/queries/find-many/post-find-many-query.js

@@ -0,0 +1,33 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPostFindManyCacheTags, createPostFindManyCacheKey } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createPostFindManyQuery(input) {
+  const { authorization, postQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPostFindManyCacheKey,
+          tags: createPostFindManyCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      if (input2?.postIds?.length === 0) {
+        return operationResult.success({ posts: [] });
+      }
+      const posts = await postQueryPort.findMany(input2);
+      return operationResult.success({ posts });
+    }
+  );
+}
+
+export { createPostFindManyQuery };

package/dist/src/application/resources/post/operations/queries/find-many/validation/schema.js

@@ -0,0 +1,11 @@
+import { POST_TYPES } from 'sitero-domain';
+import { z } from 'zod';
+import { idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const postFindManyInputSchema = () => z.object({
+  type: z.enum(POST_TYPES).optional(),
+  topicId: idSchema().nullable().optional(),
+  postIds: z.array(idSchema()).optional()
+}).optional();
+
+export { postFindManyInputSchema };

package/dist/src/application/resources/post/operations/queries/find-many/validation/validate-input.js

@@ -0,0 +1,19 @@
+import { normalizeStringSelection } from '../../../../../../conventions/normalization/normalize-string-selection.js';
+import { postFindManyInputSchema } from './schema.js';
+
+function validateInput(input) {
+  const parsedInput = postFindManyInputSchema().parse(input);
+  if (!parsedInput) {
+    return void 0;
+  }
+  const { postIds, ...criteria } = parsedInput;
+  if (postIds === void 0) {
+    return Object.keys(criteria).length ? criteria : void 0;
+  }
+  return {
+    ...criteria,
+    postIds: normalizeStringSelection(postIds)
+  };
+}
+
+export { validateInput };

package/dist/src/application/resources/post/operations/queries/find-public/cache.js

@@ -0,0 +1,12 @@
+import { createCacheKey } from '../../../../../conventions/cache/cache-key.js';
+import { createPostFindDetailCacheTags } from '../find-detail/cache.js';
+
+const createPostFindPublicCacheKey = (input) => createCacheKey("post", "find-public", {
+  id: input.id,
+  type: input.type,
+  slug: input.slug,
+  topicSlug: input.topicSlug
+});
+const createPostFindPublicCacheTags = createPostFindDetailCacheTags;
+
+export { createPostFindPublicCacheKey, createPostFindPublicCacheTags };

package/dist/src/application/resources/post/operations/queries/find-public/post-find-public-query.js

@@ -0,0 +1,36 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { PostNotFoundError } from '../../../errors/operation-errors.js';
+import { validateInput } from '../find-detail/validation/validate-input.js';
+import { createPostFindPublicCacheTags, createPostFindPublicCacheKey } from './cache.js';
+
+function createPostFindPublicQuery(input) {
+  const { postQueryPort } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPostFindPublicCacheKey,
+          tags: createPostFindPublicCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      const { post, previous, next } = await postQueryPort.findDetail({
+        ...input2,
+        isActive: true
+      });
+      if (!post) {
+        return operationResult.failure(new PostNotFoundError());
+      }
+      return operationResult.success({ post, previous, next });
+    }
+  );
+}
+
+export { createPostFindPublicQuery };

package/dist/src/application/resources/post/operations/queries/find-public-list-cards/cache.js

@@ -0,0 +1,33 @@
+import { createCacheKey, normalizeSelection } from '../../../../../conventions/cache/cache-key.js';
+import { createPostFindListCardsCacheTags } from '../find-list-cards/cache.js';
+
+const createPostFindPublicListCardsCacheKey = (input) => createCacheKey("post", "find-public", {
+  locale: input.locale,
+  searchString: input.searchString,
+  type: input.type,
+  isIndexActive: input.isIndexActive,
+  isSlugActive: input.isSlugActive,
+  isFeatured: input.isFeatured,
+  isShownOnHome: input.isShownOnHome,
+  state1: input.state1,
+  state2: input.state2,
+  state3: input.state3,
+  state4: input.state4,
+  state5: input.state5,
+  state6: input.state6,
+  state7: input.state7,
+  state8: input.state8,
+  state9: input.state9,
+  state10: input.state10,
+  topicId: input.topicId,
+  topicSlug: input.topicSlug,
+  parentId: input.parentId,
+  parentSlug: input.parentSlug,
+  postIds: normalizeSelection(input.postIds),
+  excludeIds: normalizeSelection(input.excludeIds),
+  page: input.page,
+  pageSize: input.pageSize
+});
+const createPostFindPublicListCardsCacheTags = createPostFindListCardsCacheTags;
+
+export { createPostFindPublicListCardsCacheKey, createPostFindPublicListCardsCacheTags };

package/dist/src/application/resources/post/operations/queries/find-public-list-cards/post-find-public-list-cards-query.js

@@ -0,0 +1,34 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createPostFindPublicListCardsCacheTags, createPostFindPublicListCardsCacheKey } from './cache.js';
+import { validateInput } from '../find-list-cards/validation/validate-input.js';
+
+function createPostFindPublicListCardsQuery(input) {
+  const { postQueryPort } = input;
+  return createOperation(
+    {
+      behavior: {
+        kind: "query",
+        cache: {
+          key: createPostFindPublicListCardsCacheKey,
+          tags: createPostFindPublicListCardsCacheTags
+        }
+      },
+      validate(input2) {
+        return validateInput(input2);
+      }
+    },
+    async (input2) => {
+      if (input2.postIds?.length === 0)
+        return operationResult.success({ items: [], total: 0 });
+      const { items, total } = await postQueryPort.findListCards({
+        ...input2,
+        isActive: true
+      });
+      return operationResult.success({ items, total });
+    }
+  );
+}
+
+export { createPostFindPublicListCardsQuery };

package/dist/src/application/resources/seo-metadata/errors/codes.js

@@ -0,0 +1,5 @@
+const SEO_METADATA_ERROR_CODES = {
+  POST_NOT_FOUND: "SEO_METADATA_POST_NOT_FOUND"
+};
+
+export { SEO_METADATA_ERROR_CODES };

package/dist/src/application/resources/seo-metadata/errors/operation-errors.js

@@ -0,0 +1,11 @@
+import { OperationError } from '../../../../contracts/operation/error.js';
+import { SEO_METADATA_ERROR_CODES } from './codes.js';
+
+class SeoMetadataPostNotFoundError extends OperationError {
+  constructor() {
+    super({ code: SEO_METADATA_ERROR_CODES.POST_NOT_FOUND });
+    this.name = "SeoMetadataPostNotFoundError";
+  }
+}
+
+export { SeoMetadataPostNotFoundError };

package/dist/src/application/resources/seo-metadata/operations/commands/upsert/cache.js

@@ -0,0 +1,12 @@
+import { createResourceTag, createRelationTag } from '../../../../../conventions/cache/cache-tag.js';
+
+const createSeoMetadataUpsertInvalidationTags = (input, result) => [
+  createResourceTag("seo-metadata"),
+  ...result.data.seoMetadatas.flatMap(
+    (seoMetadata) => createResourceTag("seo-metadata", { id: seoMetadata.id })
+  ),
+  createResourceTag("post", { id: input.postId }),
+  createRelationTag("post", "seo-metadata", { id: input.postId })
+].flat();
+
+export { createSeoMetadataUpsertInvalidationTags };

package/dist/src/application/resources/seo-metadata/operations/commands/upsert/seo-metadata-upsert-command.js

@@ -0,0 +1,27 @@
+import { createOperation } from '../../../../../../kernel/operation/operation.js';
+import 'zod';
+import { operationResult } from '../../../../../../contracts/operation/result.js';
+import { createSeoMetadataUpsertInvalidationTags } from './cache.js';
+import { validateInput } from './validation/validate-input.js';
+
+function createSeoMetadataUpsertCommand(input) {
+  const { authorization, seoMetadataCommandPort, postQueryPort } = input;
+  return createOperation(
+    {
+      authorization,
+      behavior: {
+        kind: "command",
+        invalidate: { tags: createSeoMetadataUpsertInvalidationTags }
+      },
+      async validate(input2) {
+        return validateInput({ input: input2, postQueryPort });
+      }
+    },
+    async (input2) => {
+      const seoMetadatas = await seoMetadataCommandPort.upsert(input2);
+      return operationResult.success({ seoMetadatas });
+    }
+  );
+}
+
+export { createSeoMetadataUpsertCommand };

package/dist/src/application/resources/seo-metadata/operations/commands/upsert/validation/schema.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { addDuplicateLocaleIssues } from '../../../../../../conventions/validation/add-duplicate-locale-issues.js';
+import { textSchema, requiredTextSchema, idSchema } from '../../../../../../conventions/validation/schema.js';
+
+const OG_TYPES = [
+  "article",
+  "book",
+  "music.song",
+  "music.album",
+  "music.playlist",
+  "music.radio_station",
+  "profile",
+  "website",
+  "video.tv_show",
+  "video.other",
+  "video.movie",
+  "video.episode"
+];
+const TWITTER_CARDS = [
+  "summary",
+  "summary_large_image",
+  "player",
+  "app"
+];
+const bcp47Schema = () => requiredTextSchema().regex(
+  /^[a-zA-Z]{2,3}(?:-[A-Z][a-z]{3})?(?:-(?:[A-Z]{2}|\d{3}))?(?:-(?:[a-zA-Z0-9]{5,8}|\d[a-zA-Z0-9]{3}))*(?:-(?:[0-9A-WY-Za-wy-z]-[a-zA-Z0-9]{2,8}(?:-[a-zA-Z0-9]{2,8})*))?(?:-x(?:-[a-zA-Z0-9]{1,8})+)?$/
+);
+const ogLocaleSchema = () => requiredTextSchema().regex(/^[a-z]{2}_[A-Z]{2}$/);
+const nullableText = textSchema().nullable();
+const nullableNumber = z.number().nullable();
+const nullableDatetime = z.iso.datetime().nullable();
+const jsonLd = z.array(z.object({}).passthrough());
+const seoMetadataUpsertInputSchema = () => z.object({
+  postId: idSchema(),
+  translations: z.array(
+    z.object({
+      locale: requiredTextSchema(),
+      title: nullableText,
+      description: nullableText,
+      author: nullableText,
+      canonical: nullableText,
+      alternate: z.array(
+        z.object({ hreflang: bcp47Schema(), href: requiredTextSchema() })
+      ),
+      robots: nullableText,
+      ogTitle: nullableText,
+      ogDescription: nullableText,
+      ogUrl: nullableText,
+      ogType: z.enum(OG_TYPES).nullable(),
+      ogSiteName: nullableText,
+      ogImage: nullableText,
+      ogImageAlt: nullableText,
+      ogImageType: nullableText,
+      ogImageWidth: nullableNumber,
+      ogImageHeight: nullableNumber,
+      ogLocale: ogLocaleSchema().nullable(),
+      ogLocaleAlternate: z.array(ogLocaleSchema()),
+      ogArticlePublishedTime: nullableDatetime,
+      ogArticleModifiedTime: nullableDatetime,
+      ogArticleAuthor: nullableText,
+      ogArticleSection: nullableText,
+      ogArticleTag: z.array(textSchema()),
+      twitterCard: z.enum(TWITTER_CARDS).nullable(),
+      twitterSite: nullableText,
+      twitterCreator: nullableText,
+      jsonLd
+    })
+  ).min(1).superRefine(addDuplicateLocaleIssues)
+}).strict();
+
+export { seoMetadataUpsertInputSchema };

package/dist/src/application/resources/seo-metadata/operations/commands/upsert/validation/validate-input.js

@@ -0,0 +1,22 @@
+import { SeoMetadataPostNotFoundError } from '../../../../errors/operation-errors.js';
+import { seoMetadataUpsertInputSchema } from './schema.js';
+
+async function validateInput(input) {
+  const validatedInput = seoMetadataUpsertInputSchema().parse(input.input);
+  const [post] = await input.postQueryPort.findMany({
+    postIds: [validatedInput.postId]
+  });
+  if (!post) {
+    throw new SeoMetadataPostNotFoundError();
+  }
+  return {
+    postId: validatedInput.postId,
+    translations: validatedInput.translations.map((translation) => ({
+      ...translation,
+      ogArticlePublishedTime: translation.ogArticlePublishedTime ? new Date(translation.ogArticlePublishedTime) : null,
+      ogArticleModifiedTime: translation.ogArticleModifiedTime ? new Date(translation.ogArticleModifiedTime) : null
+    }))
+  };
+}
+
+export { validateInput };

package/dist/src/application/sessions/admin/authenticate/admin-session-authenticate.js

@@ -0,0 +1,89 @@
+import { createAuthenticationTokens } from '../../../features/authentication/token/create-authentication-tokens.js';
+
+function createAdminSessionAuthenticate(params) {
+  const {
+    refreshTokenTtlSeconds,
+    authenticationTokenPort,
+    adminQueryPort,
+    adminRefreshTokenQueryPort,
+    adminRefreshTokenCommandPort
+  } = params;
+  return async function adminSessionAuthenticate(input) {
+    const { accessToken, refreshToken, ip, deviceInfo } = input;
+    if (accessToken) {
+      try {
+        const { actorId, role, sessionId } = authenticationTokenPort.verifyAccessToken(accessToken);
+        return {
+          status: "authenticated",
+          actor: { type: "admin", id: actorId, role },
+          session: sessionId ? { id: sessionId } : void 0,
+          refreshed: false
+        };
+      } catch {
+      }
+    }
+    if (!refreshToken) {
+      return {
+        status: "unauthenticated",
+        shouldClearSession: false
+      };
+    }
+    const tokenHash = authenticationTokenPort.hashRefreshToken(refreshToken);
+    const storedRefreshToken = await adminRefreshTokenQueryPort.find({
+      tokenHash
+    });
+    if (!storedRefreshToken) {
+      return {
+        status: "unauthenticated",
+        shouldClearSession: true
+      };
+    }
+    if (storedRefreshToken.expiresAt.getTime() <= Date.now()) {
+      await adminRefreshTokenCommandPort.delete({ id: storedRefreshToken.id });
+      return {
+        status: "unauthenticated",
+        shouldClearSession: true
+      };
+    }
+    await adminRefreshTokenCommandPort.delete({ id: storedRefreshToken.id });
+    const admin = await adminQueryPort.find({ id: storedRefreshToken.adminId });
+    if (!admin) {
+      return {
+        status: "unauthenticated",
+        shouldClearSession: true
+      };
+    }
+    const { tokens, session } = await createAuthenticationTokens({
+      actor: {
+        type: "admin",
+        id: storedRefreshToken.adminId,
+        role: admin.role
+      },
+      refreshTokenTtlSeconds,
+      authenticationTokenPort,
+      createActorRefreshToken: async ({ expiresAt, tokenHash: tokenHash2 }) => {
+        return adminRefreshTokenCommandPort.create({
+          tokenHash: tokenHash2,
+          email: storedRefreshToken.email,
+          ip,
+          deviceInfo: deviceInfo ?? null,
+          expiresAt,
+          adminId: storedRefreshToken.adminId
+        });
+      }
+    });
+    return {
+      status: "authenticated",
+      actor: {
+        type: "admin",
+        id: storedRefreshToken.adminId,
+        role: admin.role
+      },
+      session,
+      refreshed: true,
+      tokens
+    };
+  };
+}
+
+export { createAdminSessionAuthenticate };