struct-fakerator 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# 假資料結構產生器
+
+## 用途
+
+使用 faker js 時是單一純值不能產生結構，需要自己手動組合結構，此專案利用撰寫設定檔的方式來產生一個特定的假資料函數，減少手動組合結構的麻煩。
+
+```ts
+const test = {
+  type: 'obj',
+  content: {
+    name: {
+      type: 'value',
+      generateFn: () => 'hello',
+    },
+    list: {
+      type: 'arr',
+      len: 5,
+      item: {
+        type: 'value',
+        generateFn: () => 10,
+      },
+    },
+  },
+};
+
+const generateFn = createGeneratorByType(test);
+
+console.log(generateFn());
+
+/*
+{
+  name: "hello"
+  list: [10, 10, 10, 10, 10,]
+}
+*/
+```

package/biome.json

@@ -0,0 +1,20 @@
+{
+	"$schema": "https://biomejs.dev/schemas/1.7.1/schema.json",
+	"organizeImports": {
+		"enabled": true
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true
+		}
+	},
+	"formatter": {
+		"indentStyle": "space"
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	}
+}

package/jsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "es6",
+        "module": "CommonJS",
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "node_modules/*"
+            ]
+        },
+        "checkJs": true,
+    },
+    "include": [
+        "./**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "**/node_modules/*"
+    ]
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "struct-fakerator",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "vitest"
+  },
+  "keywords": [],
+  "author": "FizzyElt",
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "^1.7.1",
+    "@faker-js/faker": "^8.4.1",
+    "vitest": "^1.5.2"
+  },
+  "dependencies": {
+    "zod": "^3.23.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/config_scheme.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+
+export const valueConfigScheme = z.object({
+  type: z.string().regex(/^value$/, { message: "invalid type string" }),
+  generateFn: z.function(),
+});
+
+export const selectionConfigScheme = z.object({
+  type: z.string().regex(/^select$/, { message: "invalid type string" }),
+  items: z.any().array().nonempty({ message: "items can not be empty" }),
+});
+
+export const arrayConfigScheme = z.object({
+  type: z.string().regex(/^arr$/, { message: "invalid type string" }),
+  item: z.object({}),
+  len: z.number().nonnegative(),
+});
+
+export const tupleConfigScheme = z.object({
+  type: z.string().regex(/^tuple$/, { message: "invalid type string" }),
+  configItems: z.any().array(),
+});
+
+export const objConfigScheme = z.object({
+  type: z.string().regex(/^obj$/, { message: "invalid type string" }),
+  content: z.object({}),
+});
+
+export const boundedSeriesScheme = z
+  .object({
+    type: z
+      .string()
+      .regex(/^bounded_series$/, { message: "invalid type string" }),
+    upperLimit: z.number().nonnegative(),
+    lowerLimit: z.number().nonnegative(),
+    createInitValue: z.function().args().returns(z.number()),
+    count: z.number().nonnegative(),
+  })
+  .refine(({ upperLimit, lowerLimit }) => upperLimit >= lowerLimit, {
+    message: "lowerLimit can not greater then upperLimit",
+  })
+  .refine(({ createInitValue }) => typeof createInitValue() === "number", {
+    message: "createInitValue is not return number",
+    path: ["createInitValue"],
+  });

package/src/create_config.js

@@ -0,0 +1,109 @@
+import { faker } from "@faker-js/faker";
+import {
+  valueConfigScheme,
+  arrayConfigScheme,
+  selectionConfigScheme,
+  tupleConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+} from "./config_scheme";
+
+/**
+ * value
+ * @param {function} generateFn - The function used to generate the value.
+ * @return {ValueConfig} The configuration object with the type "value" and the provided generate function.
+ */
+export const createValueConfig = (generateFn) => {
+  const config = {
+    type: "value",
+    generateFn,
+  };
+
+  valueConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * selection
+ * @param {Array} items - The array of items to choose from.
+ * @return {SelectionConfig} The configuration object with the type "select" and the provided items.
+ */
+export const createSelectionConfig = (items) => {
+  const config = { type: "select", items };
+
+  selectionConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * object
+ * @param {object} content
+ * @return {ObjectConfig}
+ */
+export const createObjectConfig = (content) => {
+  const config = { type: "obj", content };
+
+  objConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * array
+ * @param {object} item
+ * @param {number} len
+ * @return {ArrayConfig}
+ */
+export const createArrayConfig = (item, len) => {
+  const config = { type: "arr", item, len };
+
+  arrayConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * tuple
+ * @param {Array} configItems
+ * @return {TupleConfig}
+ */
+export const createTupleConfig = (configItems) => {
+  const config = {
+    type: "tuple",
+    configItems,
+  };
+
+  tupleConfigScheme.parse(config);
+
+  return config;
+};
+
+/**
+ * bounded series
+ * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
+ * @return {BoundedSeriesConfig}
+ */
+export const createBoundedSeriesConfig = (config) => {
+  const newConfig = {
+    type: "bounded_series",
+    ...config,
+  };
+
+  boundedSeriesScheme.parse(newConfig);
+
+  return newConfig;
+};
+
+// int value
+export const createIntValueConfig = (option) =>
+  createValueConfig(() => faker.number.int(option));
+
+// float value
+export const createFloatValueConfig = (option) =>
+  createValueConfig(() => faker.number.float(option));
+
+// email value
+export const createEmailValueConfig = (option) =>
+  createValueConfig(() => faker.internet.email(option));

package/src/create_config.test.js

@@ -0,0 +1,72 @@
+import { expect, expectTypeOf, test } from "vitest";
+
+import {
+  createValueConfig,
+  createSelectionConfig,
+  createArrayConfig,
+  createTupleConfig,
+  createObjectConfig,
+  createBoundedSeriesConfig,
+} from "./create_config";
+import { createGeneratorByType } from "./create_generator_fn";
+
+test("createValueConfig", () => {
+  const valueConfig = createValueConfig(() => 44);
+
+  expect(valueConfig.type).toBe("value");
+  expect(valueConfig.generateFn).toBeTypeOf("function");
+});
+
+test("createSelectionConfig", () => {
+  const options = [1, 2, 3, 4];
+  const selectionConfig = createSelectionConfig([1, 2, 3, 4]);
+
+  expect(selectionConfig.type).toBe("select");
+  expect(selectionConfig.items).toEqual(options);
+});
+
+test("createArrayConfig", () => {
+  const valueConfig = createValueConfig(() => 44);
+  const arrConfig = createArrayConfig(valueConfig, 20);
+
+  expect(arrConfig.type).toBe("arr");
+  expect(arrConfig.len).toBe(20);
+  expect(arrConfig.item).toEqual(valueConfig);
+});
+
+test("createTupleConfig", () => {
+  const value1Config = createValueConfig(() => 123);
+  const value2Config = createValueConfig(() => "hello");
+
+  const tupleConfig = createTupleConfig([value1Config, value2Config]);
+
+  expect(tupleConfig.type).toBe("tuple");
+  expect(tupleConfig.configItems).toEqual([value1Config, value2Config]);
+});
+
+test("createObjConfig", () => {
+  const value1Config = createValueConfig(() => 32);
+  const value2Config = createValueConfig(() => "frank");
+
+  const objConfig = createObjectConfig({
+    name: value2Config,
+    age: value1Config,
+  });
+
+  expect(objConfig.type).toBe("obj");
+  expect(objConfig.content).toEqual({ name: value2Config, age: value1Config });
+});
+
+test("createBoundedSeriesConfig", () => {
+  const boundedSeriesConfig = createBoundedSeriesConfig({
+    count: 1,
+    upperLimit: 1.2,
+    lowerLimit: 1.0,
+    createInitValue: () => 40,
+  });
+
+  expect(boundedSeriesConfig.type).toBe("bounded_series");
+  expect(boundedSeriesConfig.upperLimit).toBe(1.2);
+  expect(boundedSeriesConfig.lowerLimit).toBe(1.0);
+  expect(boundedSeriesConfig.createInitValue).toBeTypeOf("function");
+});

package/src/create_generator_fn.js

@@ -0,0 +1,139 @@
+import { faker } from "@faker-js/faker";
+
+import {
+  valueConfigScheme,
+  selectionConfigScheme,
+  arrayConfigScheme,
+  objConfigScheme,
+  boundedSeriesScheme,
+  tupleConfigScheme,
+} from "./config_scheme";
+
+/**
+ * value
+ * @param {ValueConfig} config
+ * @param {number=} level
+ * @return {function}
+ */
+export const createValueGenerator = (config, level = 0) => {
+  valueConfigScheme.parse(config);
+
+  return config.generateFn;
+};
+
+/**
+ * selection
+ * @param {SelectionConfig} config
+ * @param {number=} level
+ * @return {function} The configuration object with the type "select" and the provided items.
+ */
+export const createSelectionGenerator = (config, level = 0) => {
+  selectionConfigScheme.parse(config);
+
+  const { items } = config;
+
+  return () => items[faker.number.int(items.length - 1)];
+};
+
+/**
+ * object
+ * @param {ObjectConfig} config
+ * @param {number=} level
+ * @return {() => object}
+ */
+export const createObjectGenerator = (config, level = 0) => {
+  objConfigScheme.parse(config);
+
+  const keyWithFns = Object.entries(config.content).map(([key, subConfig]) => [
+    key,
+    createGeneratorByType(subConfig, level + 1),
+  ]);
+
+  return () => {
+    const result = {};
+    for (const [key, generateFn] of keyWithFns) {
+      result[key] = generateFn();
+    }
+    return result;
+  };
+};
+
+/**
+ * array
+ * @param {ArrayConfig} config
+ * @param {number=} level
+ * @return {() => Array}
+ */
+export const createArrayGenerator = (config, level = 0) => {
+  arrayConfigScheme.parse(config);
+
+  const itemGeneratorFn = createGeneratorByType(config.item, level + 1);
+
+  return () => Array.from({ length: config.len ?? 0 }, itemGeneratorFn);
+};
+
+/**
+ * tuple
+ * @param {TupleConfig} config
+ * @param {number=} level
+ * @return {() => Array}
+ */
+export const createTupleGenerator = (config, level = 0) => {
+  tupleConfigScheme.parse(config);
+
+  const itemsFns = config.configItems.map(createGeneratorByType);
+
+  return () => itemsFns.map((generateFn) => generateFn());
+};
+
+/**
+ * bounded series
+ * @param {BoundedSeriesConfig} config
+ * @param {number} level
+ * @return {() => Array<number>}
+ */
+export const createBoundedSeriesGenerator = (config, level = 0) => {
+  boundedSeriesScheme.parse(config);
+
+  const { upperLimit, lowerLimit, createInitValue, count } = config;
+
+  return () => {
+    let value = createInitValue();
+
+    const boundedSeries = [];
+
+    for (let i = 0; i < count; i++) {
+      value = faker.number.float({ max: upperLimit, min: lowerLimit }) * value;
+      boundedSeries.push(value);
+    }
+
+    return boundedSeries;
+  };
+};
+
+/**
+ *
+ * @param {ValueConfig | SelectionConfig | ArrayConfig | ObjectConfig | TupleConfig | BoundedSeriesConfig} config
+ * @param {number=} level
+ * @return {function}
+ */
+export const createGeneratorByType = (config, level = 0) => {
+  switch (config.type) {
+    case "obj":
+      return createObjectGenerator(config, level);
+    case "arr":
+      return createArrayGenerator(config, level);
+    case "select":
+      return createSelectionGenerator(config, level);
+    case "tuple":
+      return createTupleGenerator(config, level);
+    case "value":
+      return createValueGenerator(config, level);
+    case "bounded_series":
+      return createBoundedSeriesGenerator(config, level);
+    default:
+      throw Error(
+        `level ${level} config type "${config.type}" is not supported`,
+      );
+  }
+};

package/src/create_generator_fn.test.js

@@ -0,0 +1,132 @@
+import { describe, test, expect } from "vitest";
+import { ZodError } from "zod";
+import {
+  createValueGenerator,
+  createSelectionGenerator,
+  createArrayGenerator,
+  createTupleGenerator,
+  createObjectGenerator,
+  createBoundedSeriesGenerator,
+} from "./create_generator_fn";
+
+describe("createValueGenerator", () => {
+  test("normal", () => {
+    const value = createValueGenerator({
+      type: "value",
+      generateFn: () => 50,
+    })();
+
+    expect(value).toBe(50);
+
+    const value2 = createValueGenerator({
+      type: "value",
+      generateFn: () => ({ age: 100, name: "hello" }),
+    })();
+
+    expect(value2).toEqual({ age: 100, name: "hello" });
+  });
+});
+
+describe("createSelectionGenerator", () => {
+  test("normal", () => {
+    const value = createSelectionGenerator({
+      type: "select",
+      items: [1],
+    })();
+
+    expect(value).toBe(1);
+
+    const value2 = createSelectionGenerator({
+      type: "select",
+      items: [30, 30, 30, 30],
+    })();
+
+    expect(value2).toBe(30);
+  });
+});
+
+describe("createArrayGenerator", () => {
+  test("normal", () => {
+    const list = createArrayGenerator({
+      type: "arr",
+      len: 5,
+      item: { type: "value", generateFn: () => ({ age: 42 }) },
+    })();
+
+    expect(list).toEqual([
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+      { age: 42 },
+    ]);
+  });
+});
+
+describe("createTupleGenerator", () => {
+  test("normal", () => {
+    const tuple = createTupleGenerator({
+      type: "tuple",
+      configItems: [
+        { type: "value", generateFn: () => 225 },
+        { type: "value", generateFn: () => "hello world" },
+      ],
+    })();
+
+    expect(tuple.length).toBe(2);
+    const [num, str] = tuple;
+    expect(num).toBe(225);
+    expect(str).toBe("hello world");
+  });
+});
+
+describe("createObjectGenerator", () => {
+  test("normal", () => {
+    const obj = createObjectGenerator({
+      type: "obj",
+      content: {
+        name: { type: "value", generateFn: () => "John" },
+        age: { type: "value", generateFn: () => 50 },
+        location: { type: "value", generateFn: () => "Taiwan" },
+      },
+    })();
+
+    expect(obj).toEqual({ name: "John", age: 50, location: "Taiwan" });
+  });
+});
+
+describe("createBoundedSeriesGenerator", () => {
+  test("normal", () => {
+    const upperLimit = 1.1;
+    const lowerLimit = 0.9;
+    const initValue = 100;
+    const count = 100;
+
+    const list = createBoundedSeriesGenerator({
+      type: "bounded_series",
+      upperLimit,
+      lowerLimit,
+      createInitValue: () => initValue,
+      count,
+    })();
+
+    for (let i = 0; i < count; i++) {
+      const value = list[i];
+      if (i === 0) {
+        const ratio = value / initValue;
+
+        expect(ratio).toBeLessThanOrEqual(upperLimit);
+        expect(ratio).toBeGreaterThanOrEqual(lowerLimit);
+
+        continue;
+      }
+
+      const prevValue = list[i - 1];
+
+      const ratio = value / prevValue;
+
+      expect(ratio).toBeLessThanOrEqual(upperLimit);
+      expect(ratio).toBeGreaterThanOrEqual(lowerLimit);
+    }
+  });
+});

package/src/type.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef {{ type: 'value', generateFn: Function}} ValueConfig
+ */
+
+/**
+ * @typedef {{ type: 'select', items: Array }} SelectionConfig
+ */
+
+/**
+ * @typedef {{ type: 'arr', item: Object, len: number }} ArrayConfig
+ */
+
+/**
+ * @typedef {{ type: 'tuple', configItems: Array }} TupleConfig
+ */
+
+/**
+ * @typedef {{ type: 'obj', content: Object }} ObjectConfig
+ */
+
+/**
+ * @typedef {{ type: 'bounded_series', upperLimit: number, lowerLimit: number, createInitValue: function, count: number }} BoundedSeriesConfig
+ */