@reactionary/source 0.0.27

package/core/src/schemas/models/currency.model.ts

@@ -0,0 +1,187 @@
+import { z } from 'zod';
+
+export const CurrencySchema = z.enum([
+  'AED',
+  'AFN',
+  'ALL',
+  'AMD',
+  'ANG',
+  'AOA',
+  'ARS',
+  'AUD',
+  'AWG',
+  'AZN',
+  'BAM',
+  'BBD',
+  'BDT',
+  'BGN',
+  'BHD',
+  'BIF',
+  'BMD',
+  'BND',
+  'BOB',
+  'BOV',
+  'BRL',
+  'BSD',
+  'BTN',
+  'BWP',
+  'BYN',
+  'BZD',
+  'CAD',
+  'CDF',
+  'CHE',
+  'CHF',
+  'CHW',
+  'CLF',
+  'CLP',
+  'CNY',
+  'COP',
+  'COU',
+  'CRC',
+  'CUC',
+  'CUP',
+  'CVE',
+  'CZK',
+  'DJF',
+  'DKK',
+  'DOP',
+  'DZD',
+  'EGP',
+  'ERN',
+  'ETB',
+  'EUR',
+  'FJD',
+  'FKP',
+  'GBP',
+  'GEL',
+  'GHS',
+  'GIP',
+  'GMD',
+  'GNF',
+  'GTQ',
+  'GYD',
+  'HKD',
+  'HNL',
+  'HRK',
+  'HTG',
+  'HUF',
+  'IDR',
+  'ILS',
+  'INR',
+  'IQD',
+  'IRR',
+  'ISK',
+  'JMD',
+  'JOD',
+  'JPY',
+  'KES',
+  'KGS',
+  'KHR',
+  'KMF',
+  'KPW',
+  'KRW',
+  'KWD',
+  'KYD',
+  'KZT',
+  'LAK',
+  'LBP',
+  'LKR',
+  'LRD',
+  'LSL',
+  'LYD',
+  'MAD',
+  'MDL',
+  'MGA',
+  'MKD',
+  'MMK',
+  'MNT',
+  'MOP',
+  'MRU',
+  'MUR',
+  'MVR',
+  'MWK',
+  'MXN',
+  'MXV',
+  'MYR',
+  'MZN',
+  'NAD',
+  'NGN',
+  'NIO',
+  'NOK',
+  'NPR',
+  'NZD',
+  'OMR',
+  'PAB',
+  'PEN',
+  'PGK',
+  'PHP',
+  'PKR',
+  'PLN',
+  'PYG',
+  'QAR',
+  'RON',
+  'RSD',
+  'RUB',
+  'RWF',
+  'SAR',
+  'SBD',
+  'SCR',
+  'SDG',
+  'SEK',
+  'SGD',
+  'SHP',
+  'SLE',
+  'SLL',
+  'SOS',
+  'SRD',
+  'SSP',
+  'STN',
+  'SYP',
+  'SZL',
+  'THB',
+  'TJS',
+  'TMT',
+  'TND',
+  'TOP',
+  'TRY',
+  'TTD',
+  'TVD',
+  'TWD',
+  'TZS',
+  'UAH',
+  'UGX',
+  'USD',
+  'USN',
+  'UYI',
+  'UYU',
+  'UYW',
+  'UZS',
+  'VED',
+  'VES',
+  'VND',
+  'VUV',
+  'WST',
+  'XAF',
+  'XAG',
+  'XAU',
+  'XBA',
+  'XBB',
+  'XBC',
+  'XBD',
+  'XCD',
+  'XDR',
+  'XOF',
+  'XPD',
+  'XPF',
+  'XPT',
+  'XSU',
+  'XTS',
+  'XUA',
+  'XXX',
+  'YER',
+  'ZAR',
+  'ZMW',
+  'ZWL',
+]);
+
+export type Currency = z.infer<typeof CurrencySchema>;

package/core/src/schemas/models/identifiers.model.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+
+export const FacetIdentifierSchema = z.looseInterface({
+    key: z.string().default('').nonoptional()
+});
+
+export const FacetValueIdentifierSchema = z.looseInterface({
+    facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+    key: z.string().default('')
+});
+
+export const SKUIdentifierSchema = z.looseInterface({
+    key: z.string().default('').nonoptional()
+});
+
+export const ProductIdentifierSchema = z.looseInterface({
+    key: z.string().default(''),
+});
+
+export const SearchIdentifierSchema = z.looseInterface({
+    term: z.string().default(''),
+    page: z.number().default(0),
+    pageSize: z.number().default(20),
+    facets: z.array(FacetValueIdentifierSchema.required()).default(() => [])
+});
+
+export const CartIdentifierSchema = z.looseInterface({
+    key: z.string().default('')
+});
+
+export const CartItemIdentifierSchema = z.looseInterface({
+    key: z.string().default('')
+});
+
+export const PriceIdentifierSchema = z.looseInterface({
+    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+});
+
+export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
+export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
+export type FacetIdentifier = z.infer<typeof FacetIdentifierSchema>;
+export type FacetValueIdentifier = z.infer<typeof FacetValueIdentifierSchema>;
+export type CartIdentifier = z.infer<typeof CartIdentifierSchema>;
+export type CartItemIdentifier = z.infer<typeof CartItemIdentifierSchema>;
+export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;

package/core/src/schemas/models/identity.model.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { BaseModelSchema } from './base.model';
+
+export const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
+
+export const IdentitySchema = BaseModelSchema.extend({
+    id: z.string().default(''),
+    type: IdentityTypeSchema.default("Anonymous"),
+    token: z.string().optional(),
+    issued: z.coerce.date().default(new Date()),
+    expiry: z.coerce.date().default(new Date())
+});
+
+export type IdentityType = z.infer<typeof IdentityTypeSchema>;
+export type Identity = z.infer<typeof IdentitySchema>;

package/core/src/schemas/models/inventory.model.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { BaseModelSchema } from './base.model';
+
+export const InventorySchema = BaseModelSchema.extend({
+    quantity: z.number().default(0)
+});
+
+export type Inventory = z.infer<typeof InventorySchema>;

package/core/src/schemas/models/price.model.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { BaseModelSchema } from './base.model';
+import { PriceIdentifierSchema } from './identifiers.model';
+import { CurrencySchema } from './currency.model';
+
+export const MonetaryAmountSchema = z.looseInterface({
+    cents: z.number().default(0).describe('The monetary amount in cent-precision.'),
+    currency: CurrencySchema.default("XXX").describe('The currency associated with the amount, as a ISO 4217 standardized code.')
+});
+
+export const PriceSchema = BaseModelSchema.extend({
+    identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
+    value: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({}))
+});
+
+export type MonetaryAmount = z.infer<typeof MonetaryAmountSchema>;
+export type Price = z.infer<typeof PriceSchema>;

package/core/src/schemas/models/product.model.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ProductIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema } from './base.model';
+
+export const SKUSchema = z.looseInterface({
+    identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+});
+
+export const ProductAttributeSchema = z.looseInterface({
+    id: z.string(),
+    name: z.string(),
+    value: z.string()
+});
+
+export const ProductSchema = BaseModelSchema.extend({
+    identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    slug: z.string().default(''),
+    description: z.string().default(''),
+    image: z.string().url().default('https://placehold.co/400'),
+    images: z.string().url().array().default(() => []),
+    attributes: z.array(ProductAttributeSchema).default(() => []),
+    skus: z.array(SKUSchema).default(() => [])
+});
+
+export type SKU = z.infer<typeof SKUSchema>;
+export type Product = z.infer<typeof ProductSchema>;
+export type ProductAttribute = z.infer<typeof ProductAttributeSchema>;

package/core/src/schemas/models/search.model.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema } from './base.model';
+
+export const SearchResultProductSchema = z.looseInterface({
+    identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    image: z.string().url().default('https://placehold.co/400'),
+    slug: z.string().default('')
+});
+
+export const SearchResultFacetValueSchema = z.looseInterface({
+    identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    count: z.number().default(0),
+    active: z.boolean().default(false)
+});
+
+export const SearchResultFacetSchema = z.looseInterface({
+    identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    values: z.array(SearchResultFacetValueSchema).default(() => [])
+});
+
+export const SearchResultSchema = BaseModelSchema.extend({
+    identifier: SearchIdentifierSchema.default(() => SearchIdentifierSchema.parse({})),
+    products: z.array(SearchResultProductSchema).default(() => []),
+    pages: z.number().default(0),
+    facets: z.array(SearchResultFacetSchema).default(() => [])
+});
+
+export type SearchResultProduct = z.infer<typeof SearchResultProductSchema>;
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+export type SearchResultFacet = z.infer<typeof SearchResultFacetSchema>;
+export type SearchResultFacetValue = z.infer<typeof SearchResultFacetValueSchema>;

package/core/src/schemas/mutations/analytics.mutation.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { BaseMutationSchema } from './base.mutation';
+import { ProductIdentifierSchema, SearchIdentifierSchema } from '../models/identifiers.model';
+
+export const AnalyticsMutationSearchEventSchema = BaseMutationSchema.extend({
+    mutation: z.literal('search'),
+    search: SearchIdentifierSchema.required(),
+    products: z.array(ProductIdentifierSchema),
+});
+
+export const AnalyticsMutationSearchProductClickEventSchema = BaseMutationSchema.extend({
+    mutation: z.literal('product-search-click'),
+    search: SearchIdentifierSchema.required(),
+    product: ProductIdentifierSchema.required(),
+    position: z.number().min(0)
+});
+
+export const AnalyticsMutationSchema = z.union([AnalyticsMutationSearchEventSchema, AnalyticsMutationSearchProductClickEventSchema]);
+
+export type AnalyticsMutation = z.infer<typeof AnalyticsMutationSchema>;
+export type AnalyticsMutationSearchEvent = z.infer<typeof AnalyticsMutationSearchEventSchema>;
+export type AnalyticsMutationSearchProductClickEvent = z.infer<typeof AnalyticsMutationSearchProductClickEventSchema>;

package/core/src/schemas/mutations/base.mutation.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const BaseMutationSchema = z.looseInterface({
+    mutation: z.ZodLiteral
+});
+
+export type BaseMutation = z.infer<typeof BaseMutationSchema>;

package/core/src/schemas/mutations/cart.mutation.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { BaseMutationSchema } from './base.mutation';
+import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
+
+export const CartMutationItemAddSchema = BaseMutationSchema.extend({
+    mutation: z.literal('add'),
+    cart: CartIdentifierSchema.required(),
+    product: ProductIdentifierSchema.required(),
+    quantity: z.number()
+});
+
+export const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
+    mutation: z.literal('remove'),
+    cart: CartIdentifierSchema.required(),
+    item: CartItemIdentifierSchema.required()
+});
+
+export const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
+    mutation: z.literal('adjustQuantity'),
+    cart: CartIdentifierSchema.required(),
+    item: CartItemIdentifierSchema.required(),
+    quantity: z.number()
+});
+
+export const CartMutationSchema = z.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
+
+export type CartMutation = z.infer<typeof CartMutationSchema>;
+export type CartMutationItemAdd = z.infer<typeof CartMutationItemAddSchema>;
+export type CartMutationItemRemove = z.infer<typeof CartMutationItemRemoveSchema>;
+export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;

package/core/src/schemas/mutations/identity.mutation.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { BaseMutationSchema } from './base.mutation';
+
+export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
+    mutation: z.literal('login'),
+    username: z.string(),
+    password: z.string()
+});
+
+export const IdentityMutationLogoutSchema = BaseMutationSchema.extend({
+    mutation: z.literal('logout')
+});
+
+export const IdentityMutationSchema = z.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+
+export type IdentityMutation = z.infer<typeof IdentityMutationSchema>;
+export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
+export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;

package/core/src/schemas/mutations/inventory.mutation.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const InventoryMutationSchema = z.union([]);
+
+export type InventoryMutation = z.infer<typeof InventoryMutationSchema>;

package/core/src/schemas/mutations/price.mutation.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const PriceMutationSchema = z.union([]);
+
+export type PriceMutation = z.infer<typeof PriceMutationSchema>;

package/core/src/schemas/mutations/product.mutation.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { BaseMutationSchema } from './base.mutation';
+
+export const ProductMutationSchema = z.union([]);
+
+export type ProductMutation = z.infer<typeof ProductMutationSchema>;

package/core/src/schemas/mutations/search.mutation.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const SearchMutationSchema = z.union([]);
+
+export type SearchMutation = z.infer<typeof SearchMutationSchema>;

package/core/src/schemas/queries/analytics.query.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const AnalyticsQuerySchema = z.union([]);
+
+export type AnalyticsQuery = z.infer<typeof AnalyticsQuerySchema>;

package/core/src/schemas/queries/base.query.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const BaseQuerySchema = z.looseInterface({
+    query: z.ZodLiteral
+});
+
+export type BaseQuery = z.infer<typeof BaseQuerySchema>;

package/core/src/schemas/queries/cart.query.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+import { CartIdentifierSchema } from '../models/identifiers.model';
+
+export const CartQueryByIdSchema = BaseQuerySchema.extend({
+    query: z.literal('id'),
+    cart: CartIdentifierSchema.required()
+});
+export const CartQuerySchema = z.union([CartQueryByIdSchema]);
+
+export type CartQueryById = z.infer<typeof CartQueryByIdSchema>;
+export type CartQuery = z.infer<typeof CartQuerySchema>;

package/core/src/schemas/queries/identity.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+
+export const IdentityQuerySelfSchema = BaseQuerySchema.extend({
+    query: z.literal('self')
+});
+export const IdentityQuerySchema = z.union([IdentityQuerySelfSchema]);
+
+export type IdentityQuery = z.infer<typeof IdentityQuerySchema>;
+export type IdentityQuerySelf = z.infer<typeof IdentityQuerySelfSchema>;

package/core/src/schemas/queries/inventory.query.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+
+export const InventoryQuerySchema = BaseQuerySchema.extend({
+    query: z.literal('sku'),
+    sku: z.string()
+});
+
+export type InventoryQuery = z.infer<typeof InventoryQuerySchema>;

package/core/src/schemas/queries/price.query.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+import { SKUIdentifierSchema } from '../models/identifiers.model';
+
+export const PriceQueryBySkuSchema = BaseQuerySchema.extend({
+    query: z.literal('sku'),
+    sku: SKUIdentifierSchema.required(),
+});
+export const PriceQuerySchema = z.union([PriceQueryBySkuSchema]);
+
+export type PriceQueryBySku = z.infer<typeof PriceQueryBySkuSchema>;
+export type PriceQuery = z.infer<typeof PriceQuerySchema>;

package/core/src/schemas/queries/product.query.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+
+export const ProductQueryBySlugSchema = BaseQuerySchema.extend({
+    query: z.literal('slug'),
+    slug: z.string()
+});
+
+export const ProductQueryByIdSchema = BaseQuerySchema.extend({
+    query: z.literal('id'),
+    id: z.string() 
+});
+
+export const ProductQuerySchema = z.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
+
+export type ProductQueryBySlug = z.infer<typeof ProductQueryBySlugSchema>;
+export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;
+export type ProductQuery = z.infer<typeof ProductQuerySchema>;

package/core/src/schemas/queries/search.query.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+import { SearchIdentifierSchema } from '../models/identifiers.model';
+
+export const SearchQueryByTermSchema = BaseQuerySchema.extend({
+    query: z.literal('term'),
+    search: SearchIdentifierSchema.required()
+});
+export const SearchQuerySchema = z.union([SearchQueryByTermSchema]);
+
+export type SearchQuery = z.infer<typeof SearchQuerySchema>;
+export type SearchQueryByTerm = z.infer<typeof SearchQueryByTermSchema>;

package/core/src/schemas/session.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { IdentitySchema } from './models/identity.model';
+
+export const SessionSchema = z.looseObject({
+    id: z.string(),
+    identity: IdentitySchema.default(() => IdentitySchema.parse({}))
+});
+
+export type Session = z.infer<typeof SessionSchema>;

package/core/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "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"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/core/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/core/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}