@prismicio/mock 0.0.8 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/mock",
-	"version": "0.0.8",
+	"version": "0.1.0",
 	"description": "Generate mock Prismic documents, fields, Slices, and models for development and testing environments",
 	"keywords": [
 		"typescript",
@@ -16,7 +16,6 @@
 	"license": "Apache-2.0",
 	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
 	"sideEffects": false,
-	"type": "module",
 	"exports": {
 		".": {
 			"require": "./dist/index.cjs",
@@ -49,34 +48,37 @@
 		"format": "prettier --write .",
 		"lint": "eslint --ext .js,.ts .",
 		"prepare": "npm run build",
-		"release": "npm run build && npm run test && standard-version && git push --follow-tags && npm run build && npm publish",
-		"release:alpha": "npm run build && npm run test && standard-version --release-as major --prerelease alpha && git push --follow-tags && npm run build && npm publish --tag alpha",
+		"release": "npm run test && standard-version && git push --follow-tags && npm run build && npm publish",
+		"release:alpha": "npm run test && standard-version --release-as major --prerelease alpha && git push --follow-tags && npm run build && npm publish --tag alpha",
 		"release:alpha:dry": "standard-version --release-as major --prerelease alpha --dry-run",
 		"release:dry": "standard-version --dry-run",
-		"test": "npm run lint && npm run unit",
+		"size": "size-limit",
+		"test": "npm run lint && npm run unit && npm run build && npm run size",
 		"unit": "nyc --reporter=lcovonly --reporter=text --exclude-after-remap=false ava"
 	},
 	"dependencies": {
-		"@prismicio/types": "^0.1.25",
+		"@prismicio/types": "^0.2.0",
 		"change-case": "^4.1.2",
-		"faker": "^5.5.3"
+		"rand-seed": "^1.0.1"
 	},
 	"devDependencies": {
-		"@types/faker": "^5.5.8",
-		"@typescript-eslint/eslint-plugin": "^5.12.0",
-		"@typescript-eslint/parser": "^5.12.0",
-		"ava": "^3.15.0",
-		"eslint": "^8.9.0",
-		"eslint-config-prettier": "^8.3.0",
-		"eslint-plugin-prettier": "^4.0.0",
-		"eslint-plugin-tsdoc": "^0.2.14",
+		"@size-limit/preset-small-lib": "^7.0.8",
+		"@typescript-eslint/eslint-plugin": "^5.30.5",
+		"@typescript-eslint/parser": "^5.30.5",
+		"ava": "^4.3.0",
+		"esbuild": "^0.14.48",
+		"esbuild-register": "^3.3.3",
+		"eslint": "^8.19.0",
+		"eslint-config-prettier": "^8.5.0",
+		"eslint-plugin-prettier": "^4.2.1",
+		"eslint-plugin-tsdoc": "^0.2.16",
 		"nyc": "^15.1.0",
-		"prettier": "^2.5.1",
-		"prettier-plugin-jsdoc": "^0.3.30",
+		"prettier": "^2.7.1",
+		"prettier-plugin-jsdoc": "^0.3.38",
 		"siroc": "^0.16.0",
-		"standard-version": "^9.3.2",
-		"ts-eager": "^2.0.2",
-		"typescript": "^4.5.5"
+		"size-limit": "^7.0.8",
+		"standard-version": "^9.5.0",
+		"typescript": "^4.7.4"
 	},
 	"engines": {
 		"node": ">=12.7.0"

package/src/api/createAPIMockFactory.ts

@@ -0,0 +1,56 @@
+import * as prismicT from "@prismicio/types";
+
+import { createFaker, Faker } from "../lib/createFaker";
+
+import { Seed, WithoutFakerConfig } from "../types";
+
+import { query, MockRestApiQueryConfig } from "./query";
+import { ref, MockRestApiRefConfig } from "./ref";
+import { repository, MockRestApiRepositoryConfig } from "./repository";
+import { tags, MockRestApiTagsConfig } from "./tags";
+
+export const createAPIMockFactory = (
+	...args: ConstructorParameters<typeof APIMockFactory>
+): APIMockFactory => {
+	return new APIMockFactory(...args);
+};
+
+type APIMockFactoryConfig =
+	| {
+			seed: Seed;
+	  }
+	| {
+			faker: Faker;
+	  };
+
+export class APIMockFactory {
+	private faker: Faker;
+
+	constructor(config: APIMockFactoryConfig) {
+		this.faker = "faker" in config ? config.faker : createFaker(config.seed);
+	}
+
+	get seed() {
+		return this.faker.seed;
+	}
+
+	query<Document extends prismicT.PrismicDocument = prismicT.PrismicDocument>(
+		config?: WithoutFakerConfig<MockRestApiQueryConfig<Document>>,
+	) {
+		return query({ ...config, faker: this.faker });
+	}
+
+	ref<IsScheduled extends boolean = false>(
+		config?: WithoutFakerConfig<MockRestApiRefConfig<IsScheduled>>,
+	) {
+		return ref({ ...config, faker: this.faker });
+	}
+
+	repository(config?: WithoutFakerConfig<MockRestApiRepositoryConfig>) {
+		return repository({ ...config, faker: this.faker });
+	}
+
+	tags(config?: WithoutFakerConfig<MockRestApiTagsConfig>) {
+		return tags({ ...config, faker: this.faker });
+	}
+}

package/src/api/query.ts

@@ -15,9 +15,9 @@ export type MockRestApiQueryConfig<
 export const query = <
 	Document extends prismicT.PrismicDocument = prismicT.PrismicDocument,
 >(
-	config: MockRestApiQueryConfig<Document> = {},
+	config: MockRestApiQueryConfig<Document>,
 ): prismicT.Query<Document> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	const documents = config.documents || [];
 	const page = Math.max(1, config.page ?? 1);
@@ -27,8 +27,8 @@ export const query = <
 
 	return {
 		page,
-		next_page: page < totalPages ? faker.internet.url() : null,
-		prev_page: page > 1 ? faker.internet.url() : null,
+		next_page: page < totalPages ? faker.url() : null,
+		prev_page: page > 1 ? faker.url() : null,
 		total_pages: totalPages,
 		results_size: results.length,
 		results_per_page: pageSize,

package/src/api/ref.ts

@@ -19,22 +19,22 @@ export type MockRestApiRefValue<IsScheduled extends boolean = false> = Omit<
 		: { scheduledAt?: never });
 
 export const ref = <IsScheduled extends boolean = false>(
-	config: MockRestApiRefConfig<IsScheduled> = {},
+	config: MockRestApiRefConfig<IsScheduled>,
 ): MockRestApiRefValue<IsScheduled> => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	const value: prismicT.Ref = {
-		id: faker.git.shortSha(),
-		ref: faker.git.shortSha(),
+		id: faker.hash(16),
+		ref: faker.hash(16),
 		isMasterRef: config.isMasterRef ?? false,
 		label: config.isMasterRef
 			? "Master"
-			: changeCase.capitalCase(faker.company.bsNoun()),
+			: changeCase.capitalCase(faker.words(faker.range(1, 3))),
 	};
 
 	if (config.isScheduled) {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		value.scheduledAt = timestamp({ seed: config.seed })!;
+		value.scheduledAt = timestamp({ faker })!;
 	}
 
 	return value as MockRestApiRefValue<IsScheduled>;

package/src/api/repository.ts

@@ -13,42 +13,40 @@ export type MockRestApiRepositoryConfig = {
 } & MockRestApiConfig;
 
 export const repository = (
-	config: MockRestApiRepositoryConfig = {},
+	config: MockRestApiRepositoryConfig,
 ): prismicT.Repository => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
 	const types = (config.customTypeModels || []).reduce((acc, model) => {
-		acc[model.id] = model.label;
+		acc[model.id] = model.label || model.id;
 
 		return acc;
 	}, {} as prismicT.Repository["types"]);
 
 	return {
 		refs: [
-			ref({ seed: config.seed, isMasterRef: true }),
-			...(config.withReleases
-				? [ref({ seed: config.seed }), ref({ seed: config.seed })]
-				: []),
+			ref({ faker, isMasterRef: true }),
+			...(config.withReleases ? [ref({ faker }), ref({ faker })] : []),
 		],
-		integrationFieldsRef: ref({ seed: config.seed }).ref,
+		integrationFieldsRef: ref({ faker }).ref,
 		types,
 		languages: [
 			{
-				id: faker.lorem.word(),
-				name: changeCase.capitalCase(faker.lorem.word()),
+				id: faker.word(),
+				name: changeCase.capitalCase(faker.word()),
 			},
 		],
 		tags: generateTags({
-			seed: config.seed,
+			faker,
 			min: 1,
 			max: 10,
 		}),
 		forms: {},
 		license: "All Rights Reserved",
-		version: faker.git.shortSha(),
+		version: faker.hash(7),
 		bookmarks: {},
 		experiments: {},
-		oauth_token: faker.internet.url(),
-		oauth_initiate: faker.internet.url(),
+		oauth_token: faker.url(),
+		oauth_initiate: faker.url(),
 	};
 };

package/src/api/tags.ts

@@ -1,14 +1,17 @@
 import * as prismicT from "@prismicio/types";
 
+import { createFaker } from "../lib/createFaker";
 import { generateTags } from "../lib/generateTags";
 
 import { MockRestApiConfig } from "../types";
 
 export type MockRestApiTagsConfig = MockRestApiConfig;
 
-export const tags = (config: MockRestApiTagsConfig = {}): prismicT.Tags => {
+export const tags = (config: MockRestApiTagsConfig): prismicT.Tags => {
+	const faker = config.faker || createFaker(config.seed);
+
 	return generateTags({
-		seed: config.seed,
+		faker,
 		min: 1,
 		max: 10,
 	});

package/src/createMockFactory.ts

@@ -0,0 +1,52 @@
+import { createFaker, Faker } from "./lib/createFaker";
+
+import { Seed } from "./types";
+
+import {
+	createModelMockFactory,
+	ModelMockFactory,
+} from "./model/createModelMockFactory";
+import {
+	createValueMockFactory,
+	ValueMockFactory,
+} from "./value/createValueMockFactory";
+import {
+	createAPIMockFactory,
+	APIMockFactory,
+} from "./api/createAPIMockFactory";
+
+export const createMockFactory = (
+	...args: ConstructorParameters<typeof MockFactory>
+): MockFactory => {
+	return new MockFactory(...args);
+};
+
+type PrismicMockConfig =
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  };
+
+export class MockFactory {
+	private faker: Faker;
+
+	api: APIMockFactory;
+	model: ModelMockFactory;
+	value: ValueMockFactory;
+
+	constructor(config: PrismicMockConfig) {
+		this.faker = config.faker || createFaker(config.seed);
+
+		this.api = createAPIMockFactory({ faker: this.faker });
+		this.model = createModelMockFactory({ faker: this.faker });
+		this.value = createValueMockFactory({ faker: this.faker });
+	}
+
+	get seed() {
+		return this.faker.seed;
+	}
+}

package/src/index.ts

@@ -1,3 +1,18 @@
 export * as api from "./api";
 export * as model from "./model";
 export * as value from "./value";
+
+export { createMockFactory, MockFactory } from "./createMockFactory";
+
+export {
+	createAPIMockFactory,
+	APIMockFactory,
+} from "./api/createAPIMockFactory";
+export {
+	createModelMockFactory,
+	ModelMockFactory,
+} from "./model/createModelMockFactory";
+export {
+	createValueMockFactory,
+	ValueMockFactory,
+} from "./value/createValueMockFactory";

package/src/lib/buildEmbedField.ts

@@ -1,38 +1,36 @@
 import * as prismicT from "@prismicio/types";
-import * as changeCase from "change-case";
 
-import { createFaker } from "../lib/createFaker";
+import { createFaker, Faker } from "../lib/createFaker";
 
-import { MockEmbedData, MockValueConfig } from "../types";
+import { Seed } from "../types";
 
-type BuildEmbedFieldConfig = {
-	embedData: MockEmbedData;
-} & Pick<MockValueConfig, "seed">;
+type BuildEmbedFieldConfig<
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+> = {
+	url?: string;
+	html?: string;
+	data: Data;
+} & (
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  }
+);
 
-export const buildEmbedField = (
-	config: BuildEmbedFieldConfig,
-): prismicT.EmbedField<false> => {
-	const faker = createFaker(config.seed);
+export const buildEmbedField = <
+	Data extends prismicT.AnyOEmbed = prismicT.AnyOEmbed,
+>(
+	config: BuildEmbedFieldConfig<Data>,
+): prismicT.EmbedField<Data, "filled"> => {
+	const faker = config.faker || createFaker(config.seed);
 
 	return {
-		type: faker.datatype.boolean()
-			? prismicT.EmbedType.Link
-			: prismicT.EmbedType.Rich,
-		url: config.embedData.url,
-		html: config.embedData.html,
-		title: changeCase.capitalCase(faker.lorem.words(3)),
-		version: faker.datatype
-			.number({ min: 1, max: 3, precision: 10 })
-			.toString(),
-		cache_age: faker.datatype.number(),
-		embed_url: config.embedData.embed_url,
-		author_url: faker.internet.url(),
-		author_name: faker.company.companyName(),
-		provider_name: faker.company.companyName(),
-		thumbnail_width: config.embedData.thumbnail_width,
-		thumbnail_height: config.embedData.thumbnail_height,
-		thumbnail_url: config.embedData.thumbnail_url,
-		width: faker.datatype.number({ min: 200, max: 500 }),
-		height: faker.datatype.number({ min: 200, max: 500 }),
-	};
+		embed_url: config.url ?? faker.url(),
+		html: `<div>embed html</div>`,
+		...config.data,
+	} as prismicT.EmbedField<Data, "filled">;
 };

package/src/lib/buildImageFieldImage.ts

@@ -1,15 +1,27 @@
 import * as prismicT from "@prismicio/types";
+import * as changeCase from "change-case";
 
-import { createFaker } from "../lib/createFaker";
+import { createFaker, Faker } from "../lib/createFaker";
 
-import { MockValueStateConfig, MockImageData, MockValueConfig } from "../types";
+import { MockValueStateConfig, MockImageData, Seed } from "../types";
 
 type BuildImageFieldConfig<
 	State extends prismicT.FieldState = prismicT.FieldState,
 > = {
 	imageData: MockImageData;
-	constraint?: prismicT.CustomTypeModelImageField["config"]["constraint"];
-} & Pick<MockValueConfig, "seed"> &
+	constraint?: NonNullable<
+		prismicT.CustomTypeModelImageField["config"]
+	>["constraint"];
+} & (
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  }
+) &
 	Pick<MockValueStateConfig<State>, "state">;
 
 export const buildImageFieldImage = <
@@ -25,7 +37,7 @@ export const buildImageFieldImage = <
 			copyright: null,
 		} as prismicT.ImageFieldImage<State>;
 	} else {
-		const faker = createFaker(config.seed);
+		const faker = config.faker || createFaker(config.seed);
 
 		const url = new URL(config.imageData.url);
 
@@ -41,8 +53,8 @@ export const buildImageFieldImage = <
 		return {
 			url: url.toString(),
 			dimensions,
-			alt: faker.lorem.sentence(),
-			copyright: faker.lorem.sentence(),
+			alt: changeCase.sentenceCase(faker.words(faker.range(5, 15))),
+			copyright: changeCase.sentenceCase(faker.words(faker.range(5, 15))),
 		} as prismicT.ImageFieldImage<State>;
 	}
 };

package/src/lib/createFaker.ts

@@ -1,31 +1,108 @@
-import * as fakerStatic from "faker";
-// @ts-expect-error - Missing .d.ts
-import * as fakerLocaleEN from "faker/lib/locales/en/index.js";
-// @ts-expect-error - Missing .d.ts
-import Faker from "faker/lib/index.js";
+import Rand from "rand-seed";
 
-import { FAKER_SEED } from "../constants";
+import { Seed } from "../types";
 
-export const createFaker = (seed = FAKER_SEED): typeof fakerStatic => {
-	let normalizedSeed: number | number[];
-	if (typeof seed === "string") {
-		normalizedSeed = seed.split("").map((char) => char.charCodeAt(0));
-	} else {
-		normalizedSeed = seed;
+import { lorem, loremWords } from "./lorem";
+
+export const createFaker = (seed: Seed): Faker => {
+	return new Faker(seed);
+};
+
+const DAY_MS = 1000 * 60 * 60 * 24;
+const YEAR_MS = DAY_MS * 365;
+const YEAR_2022_MS = 52 * (YEAR_MS + DAY_MS / 4);
+
+export class Faker {
+	seed: Seed;
+
+	private rand: Rand;
+
+	constructor(seed: Seed) {
+		this.seed = seed;
+
+		this.rand = new Rand(seed.toString());
 	}
 
-	const cacheKey = JSON.stringify(normalizedSeed);
+	boolean(): boolean {
+		return this.random() >= 0.5;
+	}
 
-	if (createFaker.cache[cacheKey]) {
-		return createFaker.cache[cacheKey];
+	random(): number {
+		return this.rand.next();
 	}
 
-	const fakerInstance = new Faker();
-	fakerInstance.locales["en"] = fakerLocaleEN;
-	fakerInstance.seed(normalizedSeed);
+	randomElement<T>(elements: readonly T[]): T {
+		return elements[this.range(0, elements.length)];
+	}
 
-	createFaker.cache[cacheKey] = fakerInstance;
+	randomElements<T>(elements: readonly T[]): T[] {
+		const alwaysInclude = this.randomElement(elements);
 
-	return fakerInstance;
-};
-createFaker.cache = {} as Record<string, typeof fakerStatic>;
+		return elements.filter(
+			(element) => element === alwaysInclude || this.boolean(),
+		);
+	}
+
+	range(min: number, max: number): number {
+		return Math.floor(this.rangeFloat(Math.ceil(min), Math.floor(max)));
+	}
+
+	rangeFloat(min: number, max: number): number {
+		return this.random() * (max - min) + min;
+	}
+
+	words(length: number, wordOffset = this.range(0, loremWords.length)): string {
+		return lorem(`${length}w`, wordOffset);
+	}
+
+	word(): string {
+		return this.randomElement(loremWords);
+	}
+
+	lorem(
+		length: Parameters<typeof lorem>[0],
+		wordOffset = this.range(0, loremWords.length),
+	): string {
+		return lorem(length, wordOffset);
+	}
+
+	url(): string {
+		return `https://${this.word()}.example`;
+	}
+
+	hexColor(): string {
+		return `#${this.hash(6)}`;
+	}
+
+	hash(length: number): string {
+		let hash = "";
+
+		for (let i = 0; i < length; i++) {
+			const chars = this.boolean() ? "abcdef" : "0123456789";
+
+			hash += chars[this.range(0, chars.length)];
+		}
+
+		return hash;
+	}
+
+	date(): Date {
+		return new Date(YEAR_2022_MS + this.range(-YEAR_MS * 3, YEAR_MS * 3));
+	}
+
+	dateAfter(date: Date): Date {
+		const timestamp = date.getTime();
+
+		return new Date(this.range(timestamp, timestamp + YEAR_MS * 3));
+	}
+
+	dateBefore(date: Date): Date {
+		const timestamp = date.getTime();
+
+		return new Date(this.range(timestamp - YEAR_MS * 3, timestamp));
+	}
+
+	dateBetween(min: Date, max: Date): Date {
+		return new Date(this.range(min.getTime(), max.getTime()));
+	}
+}

package/src/lib/generateCustomTypeId.ts

@@ -1,13 +1,21 @@
 import * as changeCase from "change-case";
 
-import { createFaker } from "../lib/createFaker";
+import { createFaker, Faker } from "../lib/createFaker";
 
-import { MockModelConfig } from "../types";
+import { Seed } from "../types";
 
-type GenerateFieldIdConfig = Pick<MockModelConfig, "seed">;
+type GenerateFieldIdConfig =
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  };
 
 export const generateCustomTypeId = (config: GenerateFieldIdConfig): string => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	return changeCase.snakeCase(faker.company.bsNoun());
+	return changeCase.snakeCase(faker.words(faker.range(1, 3)));
 };

package/src/lib/generateFieldId.ts

@@ -1,15 +1,21 @@
 import * as changeCase from "change-case";
 
-import { createFaker } from "../lib/createFaker";
+import { createFaker, Faker } from "../lib/createFaker";
 
-import { MockModelConfig } from "../types";
+import { Seed } from "../types";
 
-type GenerateFieldIdConfig = Pick<MockModelConfig, "seed">;
+type GenerateFieldIdConfig =
+	| {
+			seed: Seed;
+			faker?: never;
+	  }
+	| {
+			faker: Faker;
+			seed?: never;
+	  };
 
 export const generateFieldId = (config: GenerateFieldIdConfig): string => {
-	const faker = createFaker(config.seed);
+	const faker = config.faker || createFaker(config.seed);
 
-	return changeCase.snakeCase(
-		faker.lorem.words(faker.datatype.number({ min: 1, max: 3 })),
-	);
+	return changeCase.snakeCase(faker.words(faker.range(1, 3)));
 };