@basictech/schema 0.1.0-beta.0 → 0.1.0

package/.turbo/turbo-build.log

@@ -1,22 +1,23 @@
 
 
-> @basictech/schema@0.0.1 build
+> @basictech/schema@0.1.0-beta.1 build
 > tsup
 
 CLI Building entry: ./index.ts
+CLI Using tsconfig: tsconfig.json
 CLI tsup v7.2.0
 CLI Using tsup config: /Users/raz/codebook/basic/libs/client-ts/packages/schema/tsup.config.ts
-CLI Target: node16
+CLI Target: es2022
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-ESM dist/index.mjs     153.00 B
-ESM dist/index.mjs.map 210.00 B
-ESM ⚡️ Build success in 6ms
-CJS dist/index.js     1.01 KB
-CJS dist/index.js.map 253.00 B
-CJS ⚡️ Build success in 6ms
+ESM dist/index.mjs     8.36 KB
+ESM dist/index.mjs.map 19.00 KB
+ESM ⚡️ Build success in 8ms
+CJS dist/index.js     10.11 KB
+CJS dist/index.js.map 19.08 KB
+CJS ⚡️ Build success in 8ms
 DTS Build start
-DTS ⚡️ Build success in 747ms
-DTS dist/index.d.ts  64.00 B
-DTS dist/index.d.mts 64.00 B
+DTS ⚡️ Build success in 751ms
+DTS dist/index.d.ts  2.67 KB
+DTS dist/index.d.mts 2.67 KB

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @basictech/schema
 
+## 0.1.0
+
+### Minor Changes
+
+- 96e0156: update schema validation
+- ef528e9: added schema package - test
+
+## 0.1.0-beta.1
+
+### Minor Changes
+
+- update schema validation
+
 ## 0.1.0-beta.0
 
 ### Minor Changes

package/README.md

@@ -0,0 +1,161 @@
+# Basic Schema Library
+
+A TypeScript library for validating and managing Basic schemas and their data.
+
+## Installation
+
+```bash
+npm install @basictech/schema
+```
+
+## Usage
+
+```typescript
+import { validateSchema, validateData, generateEmptySchema, validateUpdateSchema } from '@basictech/schema'
+```
+
+## API Reference
+
+### `validateSchema(schema: any)`
+
+Validates if a schema follows the Basic schema format.
+
+**Parameters:**
+- `schema` (required): The schema object to validate
+
+```typescript
+const result = validateSchema(mySchema)
+// Returns: { valid: boolean, errors: ErrorObject[] }
+```
+
+### `validateData(schema: any, table: string, data: Record<string, any>, checkRequired?: boolean)`
+
+Validates data against a schema's table definition.
+
+**Parameters:**
+- `schema` (required): The schema to validate against
+- `table` (required): The table name within the schema
+- `data` (required): The data object to validate
+- `checkRequired` (optional): Whether to validate required fields (defaults to true)
+
+```typescript
+const data = {
+  name: "John",
+  age: 30
+}
+
+const result = validateData(mySchema, "users", data)
+// Returns: { valid: boolean, errors: any[], message?: string }
+```
+
+### `generateEmptySchema(project_id?: string, version?: number)`
+
+Creates a new empty schema with basic structure.
+
+**Parameters:**
+- `project_id` (optional): The project identifier (defaults to "")
+- `version` (optional): The schema version number (defaults to 0)
+
+```typescript
+const newSchema = generateEmptySchema("my-project", 1)
+```
+
+### `validateUpdateSchema(oldSchema: any, newSchema: any)`
+
+Validates schema updates by comparing an old schema with a new one.
+
+**Parameters:**
+- `oldSchema` (required): The original schema
+- `newSchema` (required): The updated schema to validate
+
+```typescript
+const result = validateUpdateSchema(oldSchema, newSchema)
+// Returns: { valid: boolean, errors?: any[], changes?: SchemaChange[], message?: string }
+```
+
+## Schema Structure
+
+A valid Basic schema follows this structure:
+
+```typescript
+{
+  project_id: string,
+  namespace?: string,
+  version: number,
+  tables: {
+    [tableName: string]: {
+      name?: string,
+      type?: "collection",
+      fields: {
+        [fieldName: string]: {
+          type: "string" | "boolean" | "number" | "json",
+          indexed?: boolean,
+          required?: boolean
+        }
+      }
+    }
+  }
+}
+```
+
+## Schema Change Types
+
+When validating schema updates, the following change types are detected:
+
+- `property_changed`: Changes to top-level properties
+- `property_removed`: Removal of top-level properties
+- `table_added`: New table added
+- `table_removed`: Existing table removed
+- `field_added`: New field added to a table
+- `field_removed`: Field removed from a table
+- `field_type_changed`: Field type modification (not allowed)
+- `field_required_changed`: Required flag modification
+- `field_property_added`: New field property added
+- `field_property_changed`: Field property modified
+- `field_property_removed`: Field property removed
+
+## Example
+
+```typescript
+import { validateSchema, validateData, generateEmptySchema } from '@basictech/schema'
+
+// Create a new schema
+const mySchema = generateEmptySchema("my-project", 1)
+
+// Add a table with fields
+mySchema.tables.users = {
+  fields: {
+    name: { type: "string", required: true },
+    age: { type: "number" },
+    isActive: { type: "boolean" },
+    metadata: { type: "json" }
+  }
+}
+
+// Validate the schema
+const validation = validateSchema(mySchema)
+if (validation.valid) {
+  console.log("Schema is valid!")
+} else {
+  console.error("Schema validation errors:", validation.errors)
+}
+
+// Validate some data
+const userData = {
+  name: "John Doe",
+  age: 30,
+  isActive: true,
+  metadata: { joined: "2024-03-20" }
+}
+
+const dataValidation = validateData(mySchema, "users", userData)
+if (dataValidation.valid) {
+  console.log("Data is valid!")
+} else {
+  console.error("Data validation error:", dataValidation.message)
+}
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -1,3 +1,86 @@
-declare function hello(): string;
+import { ErrorObject } from 'ajv';
 
-export { hello as default };
+declare function generateEmptySchema(project_id?: string, version?: number): {
+    project_id: string;
+    version: number;
+    tables: {
+        fields: {
+            example: {
+                type: string;
+            };
+        };
+    };
+};
+/**
+ * Validate a schema
+ * only checks if the schema is formatted correctly, not if can be published
+ * @param schema - The schema to validate
+ * @returns {valid: boolean, errors: any[]} - The validation result
+ */
+declare function validateSchema(schema: any): {
+    valid: boolean;
+    errors: ErrorObject[];
+};
+/**
+ * Validate data against a schema's table definition. Only checks against provided schema.
+ * @param schema - The schema to validate against
+ * @param table - The table name in the schema to validate against
+ * @param data - The data object to validate
+ * @param checkRequired - Whether to check if required fields are present (default: true)
+ * @returns {Object} Validation result containing:
+ *   - valid: boolean indicating if validation passed
+ *   - errors: Array of validation error objects
+ *   - message: Error message if validation failed
+ */
+declare function validateData(schema: any, table: string, data: Record<string, any>, checkRequired?: boolean): {
+    valid: boolean;
+    errors: ErrorObject<string, Record<string, any>, unknown>[];
+    message: string;
+} | {
+    valid: boolean;
+    errors: {
+        message: string;
+    }[];
+    message: string;
+} | {
+    valid: boolean;
+    errors: never[];
+    message?: undefined;
+};
+type SchemaChangeType = "property_changed" | "property_removed" | "table_added" | "table_removed" | "field_added" | "field_removed" | "field_type_changed" | "field_required_changed" | "field_property_added" | "field_property_changed" | "field_property_removed";
+type SchemaChange = {
+    type: SchemaChangeType;
+    property?: string;
+    table?: string;
+    field?: string;
+    old?: any;
+    new?: any;
+};
+declare function validateUpdateSchema(oldSchema: any, newSchema: any): {
+    valid: boolean;
+    errors: ErrorObject<string, Record<string, any>, unknown>[];
+    message: string;
+    changes?: undefined;
+} | {
+    valid: boolean;
+    errors: {
+        change: SchemaChange;
+        message: string;
+    }[];
+    message: string;
+    changes?: undefined;
+} | {
+    valid: boolean;
+    changes: SchemaChange[];
+    errors?: undefined;
+    message?: undefined;
+};
+
+declare const schema: {
+    validateSchema: typeof validateSchema;
+    validateData: typeof validateData;
+    generateEmptySchema: typeof generateEmptySchema;
+    validateUpdateSchema: typeof validateUpdateSchema;
+};
+
+export { schema as default, generateEmptySchema, validateData, validateSchema, validateUpdateSchema };

package/dist/index.d.ts

@@ -1,3 +1,86 @@
-declare function hello(): string;
+import { ErrorObject } from 'ajv';
 
-export { hello as default };
+declare function generateEmptySchema(project_id?: string, version?: number): {
+    project_id: string;
+    version: number;
+    tables: {
+        fields: {
+            example: {
+                type: string;
+            };
+        };
+    };
+};
+/**
+ * Validate a schema
+ * only checks if the schema is formatted correctly, not if can be published
+ * @param schema - The schema to validate
+ * @returns {valid: boolean, errors: any[]} - The validation result
+ */
+declare function validateSchema(schema: any): {
+    valid: boolean;
+    errors: ErrorObject[];
+};
+/**
+ * Validate data against a schema's table definition. Only checks against provided schema.
+ * @param schema - The schema to validate against
+ * @param table - The table name in the schema to validate against
+ * @param data - The data object to validate
+ * @param checkRequired - Whether to check if required fields are present (default: true)
+ * @returns {Object} Validation result containing:
+ *   - valid: boolean indicating if validation passed
+ *   - errors: Array of validation error objects
+ *   - message: Error message if validation failed
+ */
+declare function validateData(schema: any, table: string, data: Record<string, any>, checkRequired?: boolean): {
+    valid: boolean;
+    errors: ErrorObject<string, Record<string, any>, unknown>[];
+    message: string;
+} | {
+    valid: boolean;
+    errors: {
+        message: string;
+    }[];
+    message: string;
+} | {
+    valid: boolean;
+    errors: never[];
+    message?: undefined;
+};
+type SchemaChangeType = "property_changed" | "property_removed" | "table_added" | "table_removed" | "field_added" | "field_removed" | "field_type_changed" | "field_required_changed" | "field_property_added" | "field_property_changed" | "field_property_removed";
+type SchemaChange = {
+    type: SchemaChangeType;
+    property?: string;
+    table?: string;
+    field?: string;
+    old?: any;
+    new?: any;
+};
+declare function validateUpdateSchema(oldSchema: any, newSchema: any): {
+    valid: boolean;
+    errors: ErrorObject<string, Record<string, any>, unknown>[];
+    message: string;
+    changes?: undefined;
+} | {
+    valid: boolean;
+    errors: {
+        change: SchemaChange;
+        message: string;
+    }[];
+    message: string;
+    changes?: undefined;
+} | {
+    valid: boolean;
+    changes: SchemaChange[];
+    errors?: undefined;
+    message?: undefined;
+};
+
+declare const schema: {
+    validateSchema: typeof validateSchema;
+    validateData: typeof validateData;
+    generateEmptySchema: typeof generateEmptySchema;
+    validateUpdateSchema: typeof validateUpdateSchema;
+};
+
+export { schema as default, generateEmptySchema, validateData, validateSchema, validateUpdateSchema };