@reactionary/source 0.0.27

package/providers/fake/src/providers/identity.provider.ts

@@ -0,0 +1,91 @@
+import {
+  Identity,
+  IdentityMutation,
+  IdentityMutationLogin,
+  IdentityProvider,
+  IdentityQuery,
+  Session,
+} from '@reactionary/core';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import z from 'zod';
+import { faker } from '@faker-js/faker';
+
+export class FakeIdentityProvider<
+  T extends Identity = Identity,
+  Q extends IdentityQuery = IdentityQuery,
+  M extends IdentityMutation = IdentityMutation
+> extends IdentityProvider<T, Q, M> {
+  protected config: FakeConfiguration;
+
+  constructor(
+    config: FakeConfiguration,
+    schema: z.ZodType<T>,
+    querySchema: z.ZodType<Q, Q>,
+    mutationSchema: z.ZodType<M, M>
+  ) {
+    super(schema, querySchema, mutationSchema);
+
+    this.config = config;
+  }
+
+  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    const results = [];
+
+    for (const query of queries) {
+      const result = await this.get(session);
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override async process(
+    mutations: M[],
+    session: Session
+  ): Promise<T> {
+    let result = this.newModel();
+
+    for (const mutation of mutations) {
+      switch (mutation.mutation) {
+        case 'login':
+          result = await this.login(mutation, session);
+          break;
+        case 'logout':
+          result = await this.logout(session);
+          break;
+      }
+    }
+
+    return result;
+  }
+
+  protected async login(
+    payload: IdentityMutationLogin,
+    session: Session
+  ): Promise<T> {
+    const base = this.newModel();
+
+    base.id = faker.string.uuid();
+    base.token = faker.string.uuid();
+    base.issued = faker.date.recent();
+    base.issued = faker.date.soon();
+    base.type = 'Registered';
+
+    return base;
+  }
+
+  protected async get(session: Session): Promise<T> {
+    const base = this.schema.parse(session.identity);
+
+    return base;
+  }
+
+  protected async logout(session: Session): Promise<T> {
+    const base = this.newModel();
+
+    session.identity = base;
+
+    return base;
+  }
+}

package/providers/fake/src/providers/product.provider.ts

@@ -0,0 +1,73 @@
+import {
+  BaseMutation,
+  Product,
+  ProductMutation,
+  ProductProvider,
+  ProductQuery,
+  Session,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import { base, en, Faker } from '@faker-js/faker';
+
+export class FakeProductProvider<
+  T extends Product = Product,
+  Q extends ProductQuery = ProductQuery,
+  M extends ProductMutation = ProductMutation
+> extends ProductProvider<T, Q, M> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
+    super(schema, querySchema, mutationSchema);
+
+    this.config = config;
+  }
+
+  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    const results = new Array<T>();
+
+    for (const query of queries) {
+      const generator = new Faker({
+        seed: 42,
+        locale: [en, base],
+      });
+
+      const key = (query.id as string) || generator.commerce.isbn();
+      const slug = (query.slug as string) || generator.lorem.slug();
+
+      const product: Product = {
+        identifier: {
+          key: key,
+        },
+        name: generator.commerce.productName(),
+        slug: slug,
+        attributes: [],
+        description: generator.commerce.productDescription(),
+        image: generator.image.urlPicsumPhotos({
+          width: 600,
+          height: 600,
+        }),
+        images: [],
+        meta: {
+          cache: {
+            hit: false,
+            key: key,
+          },
+          placeholder: false
+        },
+        skus: [],
+      };
+
+      results.push(product as T);
+    }
+
+    return results;
+  }
+
+  protected override process(
+    mutation: BaseMutation[],
+    session: Session
+  ): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+}

package/providers/fake/src/providers/search.provider.ts

@@ -0,0 +1,142 @@
+import {
+  SearchIdentifier,
+  SearchMutation,
+  SearchProvider,
+  SearchQuery,
+  SearchResult,
+  SearchResultFacet,
+  SearchResultProduct,
+  Session,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import { Faker, en, base } from '@faker-js/faker';
+import { jitter } from '../utilities/jitter';
+
+export class FakeSearchProvider<
+  T extends SearchResult = SearchResult,
+  Q extends SearchQuery = SearchQuery,
+  M extends SearchMutation = SearchMutation
+> extends SearchProvider<T, Q, M> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
+    super(schema, querySchema, mutationSchema);
+
+    this.config = config;
+  }
+
+  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+    const results = [];
+
+    for (const query of queries) {
+      const result = await this.get(query.search);
+
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  protected override process(mutations: M[], session: Session): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+
+  public async get(identifier: SearchIdentifier): Promise<T> {
+    await jitter(this.config.jitter.mean, this.config.jitter.deviation);
+
+    return this.parse({}, identifier);
+  }
+
+  public parse(data: unknown, query: SearchIdentifier): T {
+    const querySpecificity =
+      20 - query.term.length - query.page - query.facets.length;
+    const totalProducts = 10 * querySpecificity;
+    const totalPages = Math.ceil(totalProducts / query.pageSize);
+    const productsOnPage = Math.min(totalProducts, query.pageSize);
+
+    const productGenerator = new Faker({
+      seed: querySpecificity,
+      locale: [en, base],
+    });
+
+    const facetGenerator = new Faker({
+      seed: 100,
+      locale: [en, base],
+    });
+
+    const products = new Array<SearchResultProduct>();
+    const facets = new Array<SearchResultFacet>();
+
+    for (let i = 0; i < productsOnPage; i++) {
+      products.push({
+        identifier: {
+          key: productGenerator.commerce.isbn(),
+        },
+        image: productGenerator.image.urlPicsumPhotos({
+          height: 300,
+          width: 300,
+          grayscale: true,
+          blur: 8
+        }),
+        name: productGenerator.commerce.productName(),
+        slug: productGenerator.lorem.slug(),
+      });
+    }
+
+    const facetBase = ['color', 'size'];
+
+    for (const base of facetBase) {
+      const facet: SearchResultFacet = {
+        identifier: {
+          key: base,
+        },
+        name: base,
+        values: [],
+      };
+
+      for (let i = 0; i < 10; i++) {
+        const valueKey = i.toString();
+        const isActive =
+          query.facets.find(
+            (x) => x.facet.key === facet.identifier.key && x.key === valueKey
+          ) !== undefined;
+
+        facet.values.push({
+          active: isActive,
+          count: facetGenerator.number.int({ min: 1, max: 50 }),
+          identifier: {
+            facet: {
+              key: facet.identifier.key,
+            },
+            key: valueKey,
+          },
+          name: facetGenerator.color.human(),
+        });
+      }
+
+      facets.push(facet);
+    }
+
+    const result = {
+      pages: totalPages,
+      identifier: {
+        term: query.term,
+        page: query.page,
+        facets: query.facets,
+        pageSize: query.pageSize,
+      },
+      facets: facets,
+      products: products,
+      meta: {
+        cache: {
+          hit: false,
+          key: ''
+        },
+        placeholder: false
+      }
+    } satisfies SearchResult;
+
+    return this.schema.parse(result);
+  }
+}

package/providers/fake/src/schema/capabilities.schema.ts

@@ -0,0 +1,10 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import { z } from 'zod';
+
+export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
+    product: true,
+    search: true,
+    identity: true
+}).partial();
+
+export type FakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/providers/fake/src/schema/configuration.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const FakeConfigurationSchema = z.looseInterface({
+  jitter: z
+    .looseInterface({
+      mean: z.number().min(0).max(10000),
+      deviation: z.number().min(0).max(5000),
+    })
+    .default({
+      mean: 0,
+      deviation: 0,
+    }),
+});
+
+export type FakeConfiguration = z.infer<typeof FakeConfigurationSchema>;

package/providers/fake/src/utilities/jitter.ts

@@ -0,0 +1,14 @@
+export async function jitter(duration: number, deviation: number) {
+    const j = gaussianRandom(duration, deviation);
+    
+    return new Promise(resolve => setTimeout(resolve, j)); 
+}
+
+
+function gaussianRandom(mean: number, deviation: number) {
+    const u = 1 - Math.random();
+    const v = Math.random();
+    const z = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v );
+
+    return z * deviation + mean;
+}

package/providers/fake/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/providers/fake/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/providers/posthog/README.md

@@ -0,0 +1,7 @@
+# provider-posthog
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build provider-posthog` to build the library.

package/providers/posthog/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/providers/posthog/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@reactionary/provider-posthog",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "main": "./index.cjs",
+  "types": "./index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.0.1",
+    "zod": "4.0.0-beta.20250430T185432"
+  }
+}

package/providers/posthog/project.json

@@ -0,0 +1,33 @@
+{
+  "name": "provider-posthog",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "providers/posthog/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/providers/posthog",
+        "main": "providers/posthog/src/index.ts",
+        "tsConfig": "providers/posthog/tsconfig.lib.json",
+        "assets": ["providers/posthog/*.md"],
+        "format": ["cjs"],
+        "generatePackageJson": true
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/providers/posthog/src/core/initialize.ts

@@ -0,0 +1,9 @@
+import { Client } from "@reactionary/core";
+import { PosthogConfiguration } from "../schema/configuration.schema";
+import { PosthogCapabilities } from "../schema/capabilities.schema";
+
+export function withPosthogCapabilities(configuration: PosthogConfiguration, capabilities: PosthogCapabilities) {
+    const client: Partial<Client> = {};
+
+    return client;
+}

package/providers/posthog/src/index.ts

@@ -0,0 +1,4 @@
+export * from './core/initialize';
+
+export * from './schema/capabilities.schema';
+export * from './schema/configuration.schema';

package/providers/posthog/src/schema/capabilities.schema.ts

@@ -0,0 +1,8 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import { z } from 'zod';
+
+export const PosthogCapabilitiesSchema = CapabilitiesSchema.pick({
+    analytics: true
+}).partial();
+
+export type PosthogCapabilities = z.infer<typeof PosthogCapabilitiesSchema>;

package/providers/posthog/src/schema/configuration.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const PosthogConfigurationSchema = z.looseInterface({
+    apiKey: z.string(),
+    host: z.string(),
+});
+
+export type PosthogConfiguration = z.infer<typeof PosthogConfigurationSchema>;

package/providers/posthog/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/providers/posthog/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/trpc/README.md

@@ -0,0 +1,7 @@
+# trpc
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build trpc` to build the library.

package/trpc/eslint.config.mjs

@@ -0,0 +1,19 @@
+import baseConfig from '../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: ['{projectRoot}/eslint.config.{js,cjs,mjs}'],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/trpc/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@reactionary/trpc",
+  "version": "0.0.1",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@trpc/server": "^11.1.2",
+    "@reactionary/core": "0.0.1",
+    "superjson": "^2.2.2",
+    "zod": "4.0.0-beta.20250430T185432"
+  }
+}

package/trpc/project.json

@@ -0,0 +1,31 @@
+{
+  "name": "trpc",
+  "$schema": "../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "trpc/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/trpc",
+        "main": "trpc/src/index.ts",
+        "tsConfig": "trpc/tsconfig.lib.json",
+        "format": ["esm"]
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/trpc/src/index.ts

@@ -0,0 +1,64 @@
+import { initTRPC } from '@trpc/server';
+import {
+  Client,
+  Session,
+} from '@reactionary/core';
+import superjson from 'superjson';
+import { z } from 'zod';
+import { BaseProvider } from '@reactionary/core';
+import { TRPCQueryProcedure, TRPCMutationProcedure } from '@trpc/server';
+
+const t = initTRPC.context<{ client: Client; session: Session }>().create({
+  transformer: superjson,
+});
+
+export const router = t.router;
+export const mergeRouters = t.mergeRouters;
+export const publicProcedure = t.procedure;
+
+export function createTRPCRouter<T extends Client = Client>(client: T) {
+  type BaseProviderKeys<T> = {
+    [K in keyof T]: T[K] extends BaseProvider ? K : never;
+  }[keyof T];
+
+  type ReactionaryRouter = {
+    [Property in BaseProviderKeys<Client>]: TRPCQueryProcedure<{
+      input: Array<z.infer<T[Property]['querySchema']>>;
+      output: Array<z.infer<Awaited<T[Property]['schema']>>>;
+      meta: any;
+    }>;
+  } & {
+    [Property in BaseProviderKeys<Client> as `${Property}Mutation`]: TRPCMutationProcedure<{
+      input: Array<z.infer<T[Property]['mutationSchema']>>;
+      output: z.infer<Awaited<T[Property]['schema']>>;
+      meta: any;
+    }>;
+  };
+
+  const routes: Record<string, any> = {};
+
+  for (const key in client) {
+    const provider = client[key];
+
+    if (provider instanceof BaseProvider) {
+      const queryKey = key as keyof ReactionaryRouter;
+      const mutationKey = key + 'Mutation' as keyof ReactionaryRouter;
+
+      routes[queryKey] = publicProcedure
+        .input(provider.querySchema.array())
+        .output(provider.schema.array())
+        .query(async (opts) => {
+          return provider.query(opts.input, opts.ctx.session);
+        });
+
+      routes[mutationKey] = publicProcedure
+        .input(provider.mutationSchema.array())
+        .output(provider.schema)
+        .mutation(async (opts) => {
+          return provider.mutate(opts.input, opts.ctx.session);
+        });
+    }
+  }
+
+  return router<ReactionaryRouter>(routes as ReactionaryRouter);
+}

package/trpc/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs"
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}