schemock 0.0.1

package/dist/schema/index.mjs

@@ -0,0 +1,681 @@
+// src/schema/types.ts
+function isComputedField(field2) {
+  return typeof field2 === "object" && field2 !== null && "_computed" in field2 && field2._computed === true;
+}
+function isRelation(field2) {
+  return typeof field2 === "object" && field2 !== null && "type" in field2 && ["hasMany", "belongsTo", "hasOne"].includes(field2.type);
+}
+function isEndpointSchema(value) {
+  return typeof value === "object" && value !== null && "_endpoint" in value && value._endpoint === true;
+}
+
+// src/schema/field.ts
+function createBaseBuilder(state) {
+  const builder = {
+    type: state.type,
+    hint: state.hint,
+    isNullable: state.isNullable,
+    isUnique: state.isUnique,
+    isReadOnly: state.isReadOnly,
+    defaultValue: state.defaultValue,
+    constraints: state.constraints,
+    items: state.items,
+    shape: state.shape,
+    target: state.target,
+    values: state.values,
+    nullable() {
+      return createBaseBuilder({ ...state, isNullable: true });
+    },
+    unique(message) {
+      return createBaseBuilder({
+        ...state,
+        isUnique: true,
+        constraints: { ...state.constraints, message: message || state.constraints?.message }
+      });
+    },
+    readOnly() {
+      return createBaseBuilder({ ...state, isReadOnly: true });
+    },
+    default(value) {
+      return createBaseBuilder({ ...state, defaultValue: value });
+    },
+    min(value, message) {
+      return createBaseBuilder({
+        ...state,
+        constraints: { ...state.constraints, min: value, message: message || state.constraints?.message }
+      });
+    },
+    max(value, message) {
+      return createBaseBuilder({
+        ...state,
+        constraints: { ...state.constraints, max: value, message: message || state.constraints?.message }
+      });
+    },
+    pattern(regex, message) {
+      return createBaseBuilder({
+        ...state,
+        constraints: { ...state.constraints, pattern: regex, message: message || state.constraints?.message }
+      });
+    }
+  };
+  return builder;
+}
+function createStringBuilder(state) {
+  const base = createBaseBuilder(state);
+  return {
+    ...base,
+    min(length, message) {
+      return createStringBuilder({
+        ...state,
+        constraints: { ...state.constraints, min: length, message: message || state.constraints?.message }
+      });
+    },
+    max(length, message) {
+      return createStringBuilder({
+        ...state,
+        constraints: { ...state.constraints, max: length, message: message || state.constraints?.message }
+      });
+    },
+    pattern(regex, message) {
+      return createStringBuilder({
+        ...state,
+        constraints: { ...state.constraints, pattern: regex, message: message || state.constraints?.message }
+      });
+    }
+  };
+}
+function createNumberBuilder(state) {
+  const base = createBaseBuilder(state);
+  return {
+    ...base,
+    min(value, message) {
+      return createNumberBuilder({
+        ...state,
+        constraints: { ...state.constraints, min: value, message: message || state.constraints?.message }
+      });
+    },
+    max(value, message) {
+      return createNumberBuilder({
+        ...state,
+        constraints: { ...state.constraints, max: value, message: message || state.constraints?.message }
+      });
+    },
+    int() {
+      return createNumberBuilder({ ...state, hint: "number.int" });
+    }
+  };
+}
+function createDateBuilder(state) {
+  const base = createBaseBuilder(state);
+  return {
+    ...base,
+    past() {
+      return createDateBuilder({ ...state, hint: "date.past" });
+    },
+    future() {
+      return createDateBuilder({ ...state, hint: "date.future" });
+    },
+    recent() {
+      return createDateBuilder({ ...state, hint: "date.recent" });
+    },
+    between(options) {
+      return createDateBuilder({
+        ...state,
+        hint: "date.between",
+        constraints: {
+          ...state.constraints,
+          // Store date range in constraints for MockAdapter to use
+          min: new Date(options.from).getTime(),
+          max: new Date(options.to).getTime()
+        }
+      });
+    }
+  };
+}
+function createEnumBuilder(values, defaultVal) {
+  const state = {
+    type: "enum",
+    values,
+    hint: "helpers.arrayElement",
+    defaultValue: defaultVal
+  };
+  const base = createBaseBuilder(state);
+  return {
+    ...base,
+    default(value) {
+      return createEnumBuilder(values, value);
+    }
+  };
+}
+function createRefBuilder(target) {
+  const state = {
+    type: "ref",
+    target,
+    hint: "string.uuid"
+  };
+  return {
+    ...createBaseBuilder(state),
+    target
+  };
+}
+function createArrayBuilder(itemType, constraints) {
+  const state = {
+    type: "array",
+    items: itemType,
+    hint: "array",
+    constraints
+  };
+  const base = createBaseBuilder(state);
+  return {
+    ...base,
+    min(length) {
+      return createArrayBuilder(itemType, { ...constraints, min: length });
+    },
+    max(length) {
+      return createArrayBuilder(itemType, { ...constraints, max: length });
+    },
+    length(count) {
+      return createArrayBuilder(itemType, { ...constraints, min: count, max: count });
+    }
+  };
+}
+function createObjectBuilder(shape) {
+  const state = {
+    type: "object",
+    shape,
+    hint: "object"
+  };
+  return {
+    ...createBaseBuilder(state),
+    shape
+  };
+}
+function createComputedField(config) {
+  return {
+    ...config,
+    _computed: true
+  };
+}
+var field = {
+  // -------------------------------------------------------------------------
+  // Primitive Types
+  // -------------------------------------------------------------------------
+  /**
+   * UUID v4 string field
+   * @returns FieldBuilder<string>
+   */
+  uuid() {
+    return createBaseBuilder({ type: "uuid", hint: "string.uuid" });
+  },
+  /**
+   * String field with optional hint for mock data generation
+   * @param opts - Options including faker hint
+   */
+  string(opts) {
+    return createStringBuilder({ type: "string", hint: opts?.hint || "lorem.word" });
+  },
+  /**
+   * Number field with optional constraints
+   * @param opts - Min, max, and integer constraints
+   */
+  number(opts) {
+    const constraints = {};
+    if (opts?.min !== void 0) constraints.min = opts.min;
+    if (opts?.max !== void 0) constraints.max = opts.max;
+    return createNumberBuilder({
+      type: "number",
+      hint: opts?.int ? "number.int" : "number.float",
+      constraints: Object.keys(constraints).length > 0 ? constraints : void 0
+    });
+  },
+  /**
+   * Boolean field
+   */
+  boolean() {
+    return createBaseBuilder({ type: "boolean", hint: "datatype.boolean" });
+  },
+  /**
+   * Date field with optional constraints
+   * @param opts - Past/future constraints
+   */
+  date(opts) {
+    let hint = "date.anytime";
+    if (opts?.past) hint = "date.past";
+    if (opts?.future) hint = "date.future";
+    return createDateBuilder({ type: "date", hint });
+  },
+  // -------------------------------------------------------------------------
+  // Semantic Types (Faker-based)
+  // -------------------------------------------------------------------------
+  /**
+   * Email string field
+   */
+  email() {
+    return createStringBuilder({ type: "string", hint: "internet.email" });
+  },
+  /**
+   * URL string field
+   */
+  url() {
+    return createStringBuilder({ type: "string", hint: "internet.url" });
+  },
+  // -------------------------------------------------------------------------
+  // Faker Namespace Proxies
+  // -------------------------------------------------------------------------
+  /**
+   * Person-related fields (names, titles, etc.)
+   */
+  person: {
+    fullName() {
+      return createStringBuilder({ type: "string", hint: "person.fullName" });
+    },
+    firstName() {
+      return createStringBuilder({ type: "string", hint: "person.firstName" });
+    },
+    lastName() {
+      return createStringBuilder({ type: "string", hint: "person.lastName" });
+    },
+    bio() {
+      return createStringBuilder({ type: "string", hint: "person.bio" });
+    },
+    jobTitle() {
+      return createStringBuilder({ type: "string", hint: "person.jobTitle" });
+    }
+  },
+  /**
+   * Internet-related fields (emails, URLs, usernames, etc.)
+   */
+  internet: {
+    email() {
+      return createStringBuilder({ type: "string", hint: "internet.email" });
+    },
+    url() {
+      return createStringBuilder({ type: "string", hint: "internet.url" });
+    },
+    avatar() {
+      return createStringBuilder({ type: "string", hint: "internet.avatar" });
+    },
+    userName() {
+      return createStringBuilder({ type: "string", hint: "internet.userName" });
+    },
+    password() {
+      return createStringBuilder({ type: "string", hint: "internet.password" });
+    }
+  },
+  /**
+   * Lorem ipsum text generation
+   */
+  lorem: {
+    word() {
+      return createStringBuilder({ type: "string", hint: "lorem.word" });
+    },
+    sentence() {
+      return createStringBuilder({ type: "string", hint: "lorem.sentence" });
+    },
+    paragraph() {
+      return createStringBuilder({ type: "string", hint: "lorem.paragraph" });
+    },
+    paragraphs(count = 3) {
+      return createStringBuilder({ type: "string", hint: `lorem.paragraphs:${count}` });
+    }
+  },
+  /**
+   * Location-related fields (addresses, cities, etc.)
+   */
+  location: {
+    city() {
+      return createStringBuilder({ type: "string", hint: "location.city" });
+    },
+    country() {
+      return createStringBuilder({ type: "string", hint: "location.country" });
+    },
+    streetAddress() {
+      return createStringBuilder({ type: "string", hint: "location.streetAddress" });
+    },
+    zipCode() {
+      return createStringBuilder({ type: "string", hint: "location.zipCode" });
+    },
+    latitude() {
+      return createNumberBuilder({ type: "number", hint: "location.latitude" });
+    },
+    longitude() {
+      return createNumberBuilder({ type: "number", hint: "location.longitude" });
+    }
+  },
+  /**
+   * Phone-related fields
+   */
+  phone: {
+    number() {
+      return createStringBuilder({ type: "string", hint: "phone.number" });
+    }
+  },
+  /**
+   * Image-related fields
+   */
+  image: {
+    avatar() {
+      return createStringBuilder({ type: "string", hint: "image.avatar" });
+    },
+    url(options) {
+      const hint = options ? `image.url:${options.width || 640}x${options.height || 480}` : "image.url";
+      return createStringBuilder({ type: "string", hint });
+    }
+  },
+  /**
+   * Company-related fields
+   */
+  company: {
+    name() {
+      return createStringBuilder({ type: "string", hint: "company.name" });
+    },
+    catchPhrase() {
+      return createStringBuilder({ type: "string", hint: "company.catchPhrase" });
+    }
+  },
+  /**
+   * Commerce-related fields
+   */
+  commerce: {
+    productName() {
+      return createStringBuilder({ type: "string", hint: "commerce.productName" });
+    },
+    price() {
+      return createNumberBuilder({ type: "number", hint: "commerce.price" });
+    },
+    department() {
+      return createStringBuilder({ type: "string", hint: "commerce.department" });
+    }
+  },
+  // -------------------------------------------------------------------------
+  // Complex Types
+  // -------------------------------------------------------------------------
+  /**
+   * Enum field with type-safe values
+   * @param values - Allowed enum values
+   *
+   * @example
+   * ```typescript
+   * field.enum(['admin', 'user', 'guest']).default('user')
+   * ```
+   */
+  enum(values) {
+    return createEnumBuilder(values);
+  },
+  /**
+   * Reference to another entity
+   * @param target - Target entity name
+   *
+   * @example
+   * ```typescript
+   * field.ref('user')  // References the 'user' entity
+   * ```
+   */
+  ref(target) {
+    return createRefBuilder(target);
+  },
+  /**
+   * Array of items
+   * @param itemType - The field definition for array items
+   *
+   * @example
+   * ```typescript
+   * field.array(field.string())          // Array of strings
+   * field.array(field.uuid()).length(5)  // Fixed-length array
+   * ```
+   */
+  array(itemType) {
+    return createArrayBuilder(itemType);
+  },
+  /**
+   * Nested object with defined shape
+   * @param shape - Object shape definition
+   *
+   * @example
+   * ```typescript
+   * field.object({
+   *   street: field.location.streetAddress(),
+   *   city: field.location.city(),
+   *   zip: field.location.zipCode(),
+   * })
+   * ```
+   */
+  object(shape) {
+    return createObjectBuilder(shape);
+  },
+  /**
+   * Computed field that derives its value from other fields or data
+   * @param config - Computed field configuration
+   *
+   * @example
+   * ```typescript
+   * field.computed({
+   *   mock: () => faker.person.fullName(),
+   *   resolve: (entity) => `${entity.firstName} ${entity.lastName}`,
+   *   dependsOn: ['firstName', 'lastName'],
+   * })
+   * ```
+   */
+  computed(config) {
+    return createComputedField(config);
+  }
+};
+
+// src/schema/relations.ts
+function hasOne(target, options) {
+  return {
+    type: "hasOne",
+    target,
+    foreignKey: options?.foreignKey,
+    eager: options?.eager
+  };
+}
+function hasMany(target, options) {
+  return {
+    type: "hasMany",
+    target,
+    foreignKey: options?.foreignKey,
+    orderBy: options?.orderBy,
+    limit: options?.limit,
+    through: options?.through,
+    otherKey: options?.otherKey
+  };
+}
+function belongsTo(target, options) {
+  return {
+    type: "belongsTo",
+    target,
+    foreignKey: options?.foreignKey,
+    eager: options?.eager
+  };
+}
+
+// src/schema/define-data.ts
+function convertToFieldDefinition(field2) {
+  const isBuilder = "isNullable" in field2 || "isUnique" in field2 || "isReadOnly" in field2 || "defaultValue" in field2;
+  if (!isBuilder) {
+    return field2;
+  }
+  const builder = field2;
+  const definition = {
+    type: builder.type,
+    hint: builder.hint,
+    nullable: builder.isNullable,
+    unique: builder.isUnique,
+    readOnly: builder.isReadOnly,
+    default: builder.defaultValue,
+    constraints: builder.constraints,
+    target: builder.target,
+    values: builder.values
+  };
+  if (builder.items) {
+    definition.items = builder.items;
+  }
+  if (builder.shape) {
+    definition.shape = builder.shape;
+  }
+  return definition;
+}
+function defineData(name, definitions, options) {
+  const fields = {};
+  const relations = {};
+  const computed = {};
+  for (const [key, value] of Object.entries(definitions)) {
+    if (isComputedField(value)) {
+      computed[key] = value;
+    } else if (isRelation(value)) {
+      relations[key] = value;
+    } else {
+      const fieldValue = value;
+      fields[key] = convertToFieldDefinition(fieldValue);
+    }
+  }
+  if (!fields.id) {
+    fields.id = {
+      type: "uuid",
+      hint: "string.uuid",
+      readOnly: true
+    };
+  }
+  const timestamps = options?.timestamps ?? true;
+  if (timestamps) {
+    if (!fields.createdAt) {
+      fields.createdAt = {
+        type: "date",
+        hint: "date.past",
+        readOnly: true
+      };
+    }
+    if (!fields.updatedAt) {
+      fields.updatedAt = {
+        type: "date",
+        hint: "date.recent",
+        readOnly: true
+      };
+    }
+  }
+  const schema = {
+    name,
+    fields,
+    timestamps,
+    api: options?.api,
+    rls: options?.rls
+  };
+  if (Object.keys(relations).length > 0) {
+    schema.relations = relations;
+  }
+  if (Object.keys(computed).length > 0) {
+    schema.computed = computed;
+  }
+  return schema;
+}
+
+// src/schema/define-view.ts
+function embed(entity, config) {
+  return {
+    _embed: true,
+    entity,
+    config
+  };
+}
+function isEmbedMarker(value) {
+  return typeof value === "object" && value !== null && "_embed" in value && value._embed === true;
+}
+function pick(entity, fields) {
+  const result = {};
+  for (const fieldName of fields) {
+    if (fieldName in entity.fields) {
+      result[fieldName] = entity.fields[fieldName];
+    }
+  }
+  return result;
+}
+function omit(entity, fields) {
+  const result = { ...entity.fields };
+  for (const fieldName of fields) {
+    delete result[fieldName];
+  }
+  return result;
+}
+function defineView(name, fields, options) {
+  const processedFields = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (isEmbedMarker(value)) {
+      processedFields[key] = {
+        _embed: true,
+        entity: value.entity,
+        config: value.config
+      };
+    } else if (typeof value === "object" && value !== null && !("type" in value) && !("_computed" in value)) {
+      processedFields[key] = value;
+    } else {
+      processedFields[key] = value;
+    }
+  }
+  return {
+    name,
+    fields: processedFields,
+    endpoint: options.endpoint,
+    params: options.params
+  };
+}
+
+// src/schema/define-endpoint.ts
+function normalizeField(field2) {
+  const isBuilder = "isNullable" in field2 || "isUnique" in field2 || "isReadOnly" in field2 || "defaultValue" in field2;
+  if (!isBuilder) {
+    return field2;
+  }
+  const builder = field2;
+  const definition = {
+    type: builder.type,
+    hint: builder.hint,
+    nullable: builder.isNullable,
+    unique: builder.isUnique,
+    readOnly: builder.isReadOnly,
+    default: builder.defaultValue,
+    constraints: builder.constraints,
+    target: builder.target,
+    values: builder.values
+  };
+  if (builder.items) {
+    definition.items = builder.items;
+  }
+  if (builder.shape) {
+    definition.shape = builder.shape;
+  }
+  return definition;
+}
+function normalizeFields(fields) {
+  const result = {};
+  if (!fields) return result;
+  for (const [key, value] of Object.entries(fields)) {
+    result[key] = normalizeField(value);
+  }
+  return result;
+}
+function defineEndpoint(path, config) {
+  if (!path.startsWith("/")) {
+    throw new Error(`Endpoint path must start with '/': ${path}`);
+  }
+  const params = normalizeFields(config.params);
+  const body = normalizeFields(config.body);
+  const response = normalizeFields(config.response);
+  if (Object.keys(body).length > 0 && config.method === "GET") {
+    console.warn(`Warning: GET endpoints typically don't have a body. Consider using params instead for ${path}`);
+  }
+  return {
+    path,
+    method: config.method,
+    params,
+    body,
+    response,
+    mockResolver: config.mockResolver,
+    description: config.description,
+    _endpoint: true
+  };
+}
+
+export { belongsTo, defineData, defineEndpoint, defineView, embed, field, hasMany, hasOne, isComputedField, isEmbedMarker, isEndpointSchema, isRelation, omit, pick };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map