@naturalcycles/db-lib 8.12.0 → 8.13.0

package/src/commondao/common.dao.ts

@@ -2,6 +2,7 @@ import {
   AppError,
   AsyncMapper,
   ErrorMode,
+  JsonSchemaObject,
   _filterNullishValues,
   _passthroughPredicate,
   _since,
@@ -27,7 +28,6 @@ import {
 import { DBLibError } from '../cnst'
 import { DBModelType, ObjectWithId, RunQueryResult, Saved } from '../db.model'
 import { DBQuery, RunnableDBQuery } from '../query/dbQuery'
-import { CommonSchema } from '../schema/common.schema'
 import {
   CommonDaoCfg,
   CommonDaoCreateOptions,
@@ -874,13 +874,13 @@ export class CommonDao<
     return convertedValue
   }
 
-  async getTableSchema(): Promise<CommonSchema> {
+  async getTableSchema(): Promise<JsonSchemaObject<DBM>> {
     return await this.cfg.db.getTableSchema<DBM>(this.cfg.table)
   }
 
-  async createTable(schema: CommonSchema, opt?: CommonDaoCreateOptions): Promise<void> {
+  async createTable(schema: JsonSchemaObject<DBM>, opt?: CommonDaoCreateOptions): Promise<void> {
     this.requireWriteAccess()
-    await this.cfg.db.createTable(schema, opt)
+    await this.cfg.db.createTable(this.cfg.table, schema as any, opt)
   }
 
   /**

package/src/index.ts

@@ -67,8 +67,6 @@ import {
   DBQueryOrder,
   RunnableDBQuery,
 } from './query/dbQuery'
-import { CommonSchema, CommonSchemaField, DATA_TYPE } from './schema/common.schema'
-import { CommonSchemaGenerator, CommonSchemaGeneratorCfg } from './schema/commonSchemaGenerator'
 import { DBTransaction, RunnableDBTransaction } from './transaction/dbTransaction'
 import { commitDBTransactionSimple, mergeDBOperations } from './transaction/dbTransaction.util'
 
@@ -110,9 +108,6 @@ export type {
   DBPipelineBackupOptions,
   DBPipelineRestoreOptions,
   DBPipelineCopyOptions,
-  CommonSchema,
-  CommonSchemaField,
-  CommonSchemaGeneratorCfg,
   CommonDBAdapter,
   DBOperation,
   DBSaveBatchOperation,
@@ -143,7 +138,6 @@ export {
   dbPipelineBackup,
   dbPipelineRestore,
   dbPipelineCopy,
-  DATA_TYPE,
   getDB,
   DBLibError,
   BaseCommonDB,
@@ -151,6 +145,5 @@ export {
   RunnableDBTransaction,
   mergeDBOperations,
   commitDBTransactionSimple,
-  CommonSchemaGenerator,
   CommonKeyValueDao,
 }

package/src/pipeline/dbPipelineBackup.ts

@@ -15,7 +15,6 @@ import * as fs from 'fs-extra'
 import { createGzip, ZlibOptions } from 'zlib'
 import { CommonDB } from '../common.db'
 import { DBQuery } from '../index'
-import { CommonSchemaGenerator } from '../schema/commonSchemaGenerator'
 
 export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
   /**
@@ -102,7 +101,7 @@ export interface DBPipelineBackupOptions extends TransformLogProgressOptions {
    * @default false
    * If true - will use CommonSchemaGenerator to detect schema from input data.
    */
-  emitSchemaFromData?: boolean
+  // emitSchemaFromData?: boolean
 
   /**
    * @default false
@@ -140,7 +139,6 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
     transformMapOptions,
     errorMode = ErrorMode.SUPPRESS,
     emitSchemaFromDB = false,
-    emitSchemaFromData = false,
     sortObjects = false,
   } = opt
   const strict = errorMode !== ErrorMode.SUPPRESS
@@ -193,10 +191,6 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
         console.log(`>> ${grey(schemaFilePath)} saved (generated from DB)`)
       }
 
-      const schemaGen = emitSchemaFromData
-        ? new CommonSchemaGenerator({ table, sortedFields: true })
-        : undefined
-
       await _pipeline([
         db.streamQuery(q),
         transformLogProgress({
@@ -210,9 +204,8 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
           ...transformMapOptions,
           metric: table,
         }),
-        transformTap(row => {
+        transformTap(() => {
           rows++
-          if (schemaGen) schemaGen.add(row)
         }),
         transformToNDJson({ strict, sortObjects }),
         ...(gzip ? [createGzip(zlibOptions)] : []), // optional gzip
@@ -229,12 +222,6 @@ export async function dbPipelineBackup(opt: DBPipelineBackupOptions): Promise<ND
 
       console.log(`>> ${grey(filePath)}\n` + stats.toPretty())
 
-      if (schemaGen) {
-        const schema = schemaGen.generate()
-        await fs.writeJson(schemaFilePath, schema, { spaces: 2 })
-        console.log(`>> ${grey(schemaFilePath)} saved (generated from data)`)
-      }
-
       statsPerTable[table] = stats
     },
     { concurrency, errorMode },

package/src/pipeline/dbPipelineRestore.ts

@@ -179,7 +179,7 @@ export async function dbPipelineRestore(opt: DBPipelineRestoreOptions): Promise<
       }
 
       const schema = await fs.readJson(schemaFilePath)
-      await db.createTable(schema, { dropIfExists: true })
+      await db.createTable(table, schema, { dropIfExists: true })
     })
   }
 

package/src/testing/dbTest.ts

@@ -97,7 +97,7 @@ export function runCommonDBTest(
   // CREATE TABLE, DROP
   if (createTable) {
     test('createTable, dropIfExists=true', async () => {
-      await db.createTable(getTestItemSchema(), { dropIfExists: true })
+      await db.createTable(TEST_TABLE, getTestItemSchema(), { dropIfExists: true })
     })
   }
 

package/src/testing/test.model.ts

@@ -1,4 +1,4 @@
-import { jsonSchema, _range } from '@naturalcycles/js-lib'
+import { jsonSchema, JsonSchemaObject, _range } from '@naturalcycles/js-lib'
 import {
   binarySchema,
   booleanSchema,
@@ -6,7 +6,6 @@ import {
   objectSchema,
   stringSchema,
 } from '@naturalcycles/nodejs-lib'
-import { CommonSchema, CommonSchemaGenerator } from '..'
 import { BaseDBEntity, baseDBEntitySchema, Saved, savedDBEntitySchema } from '../db.model'
 
 const MOCK_TS_2018_06_21 = 1529539200
@@ -95,6 +94,19 @@ export function createTestItemsBM(count = 1): Saved<TestItemBM>[] {
   return _range(1, count + 1).map(num => createTestItemBM(num))
 }
 
-export function getTestItemSchema(): CommonSchema<TestItemDBM> {
-  return CommonSchemaGenerator.generateFromRows({ table: TEST_TABLE }, createTestItemsDBM())
+const testItemJsonSchema = jsonSchema
+  .object<TestItemDBM>({
+    id: jsonSchema.string(),
+    k1: jsonSchema.string(),
+    k2: jsonSchema.string(),
+    k3: jsonSchema.number(),
+    even: jsonSchema.boolean(),
+    created: jsonSchema.unixTimestamp(),
+    updated: jsonSchema.unixTimestamp(),
+  })
+  .build()
+
+export function getTestItemSchema(): JsonSchemaObject<TestItemDBM> {
+  // return CommonSchemaGenerator.generateFromRows({ table: TEST_TABLE }, createTestItemsDBM())
+  return testItemJsonSchema
 }

package/dist/schema/common.schema.d.ts

@@ -1,38 +0,0 @@
-export interface CommonSchema<ROW = any> {
-    /**
-     * Name of the Table
-     */
-    table: string;
-    fields: CommonSchemaField[];
-}
-export interface CommonSchemaField {
-    name: string;
-    type: DATA_TYPE;
-    /**
-     * If it's an Array - then parentType should tell "array of what?"
-     */
-    arrayOf?: CommonSchemaField;
-    /**
-     * If it's an Object - defined the CommonSchemaField of that object
-     */
-    objectFields?: CommonSchemaField[];
-    notNull?: boolean;
-    /**
-     * Applicable to certain fields, e.g String, to be able to autodetect limits for certain Databases
-     */
-    maxLen?: number;
-    minLen?: number;
-}
-export declare enum DATA_TYPE {
-    UNKNOWN = "UNKNOWN",
-    NULL = "NULL",
-    STRING = "STRING",
-    INT = "INT",
-    FLOAT = "FLOAT",
-    BOOLEAN = "BOOLEAN",
-    BINARY = "BINARY",
-    LOCAL_DATE = "LOCAL_DATE",
-    TIMESTAMP = "TIMESTAMP",
-    ARRAY = "ARRAY",
-    OBJECT = "OBJECT"
-}

package/dist/schema/common.schema.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DATA_TYPE = void 0;
-var DATA_TYPE;
-(function (DATA_TYPE) {
-    DATA_TYPE["UNKNOWN"] = "UNKNOWN";
-    DATA_TYPE["NULL"] = "NULL";
-    DATA_TYPE["STRING"] = "STRING";
-    DATA_TYPE["INT"] = "INT";
-    DATA_TYPE["FLOAT"] = "FLOAT";
-    DATA_TYPE["BOOLEAN"] = "BOOLEAN";
-    DATA_TYPE["BINARY"] = "BINARY";
-    DATA_TYPE["LOCAL_DATE"] = "LOCAL_DATE";
-    DATA_TYPE["TIMESTAMP"] = "TIMESTAMP";
-    // Semi-structured
-    DATA_TYPE["ARRAY"] = "ARRAY";
-    DATA_TYPE["OBJECT"] = "OBJECT";
-})(DATA_TYPE = exports.DATA_TYPE || (exports.DATA_TYPE = {}));

package/dist/schema/commonSchemaGenerator.d.ts

@@ -1,35 +0,0 @@
-import { ErrorMode } from '@naturalcycles/js-lib';
-import { CommonSchema } from './common.schema';
-export interface CommonSchemaGeneratorCfg {
-    /**
-     * Name of the Table
-     */
-    table: string;
-    /**
-     * @default SUPPRESS
-     *
-     * On error (field has multiple types):
-     * if ErrorMode.THROW_IMMEDIATE - will throw on .add()
-     * if ErrorMode.THROW_AGGREGATED - will throw on .generate()
-     */
-    errorMode?: ErrorMode;
-    /**
-     * @default false
-     * If true - fields will be sorted by name alphabetically (also inside objects)
-     */
-    sortedFields?: boolean;
-}
-/**
- * Class that helps to generate CommonSchema by processing ALL rows through it.
- */
-export declare class CommonSchemaGenerator<ROW = any> {
-    cfg: CommonSchemaGeneratorCfg;
-    constructor(cfg: CommonSchemaGeneratorCfg);
-    private fieldByName;
-    private nullableFields;
-    add(row: ROW): void;
-    private mergeFields;
-    private detectType;
-    generate(): CommonSchema<ROW>;
-    static generateFromRows<ROW>(cfg: CommonSchemaGeneratorCfg, rows?: ROW[]): CommonSchema<ROW>;
-}

package/dist/schema/commonSchemaGenerator.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommonSchemaGenerator = void 0;
-const js_lib_1 = require("@naturalcycles/js-lib");
-const common_schema_1 = require("./common.schema");
-const LOCAL_DATE_PATTERN = new RegExp(/[0-9]{4}-[01][0-9]-[0-3][0-9]/);
-/**
- * Class that helps to generate CommonSchema by processing ALL rows through it.
- */
-class CommonSchemaGenerator {
-    constructor(cfg) {
-        this.cfg = cfg;
-        this.fieldByName = {};
-        this.nullableFields = new Set();
-    }
-    // private fieldsWithMultipleTypes: Record<string, DATA_TYPE[]> = {}
-    add(row) {
-        if (!row)
-            return; // safety
-        Object.entries(row).forEach(([fieldName, value]) => {
-            this.fieldByName[fieldName] = this.mergeFields(this.fieldByName[fieldName], this.detectType(fieldName, value));
-            if (this.fieldByName[fieldName].type === common_schema_1.DATA_TYPE.NULL) {
-                this.nullableFields.add(fieldName);
-            }
-        });
-        // missing fields
-        Object.keys(this.fieldByName).forEach(fieldName => {
-            if (!(fieldName in row)) {
-                // missing field!
-                this.nullableFields.add(fieldName);
-            }
-        });
-    }
-    mergeFields(existing, newField) {
-        if (!existing)
-            return newField;
-        if (newField.type === common_schema_1.DATA_TYPE.UNKNOWN || newField.type === common_schema_1.DATA_TYPE.NULL) {
-            return {
-                ...existing,
-            };
-        }
-        if (existing.type === common_schema_1.DATA_TYPE.UNKNOWN || existing.type === common_schema_1.DATA_TYPE.NULL) {
-            return {
-                ...newField,
-            };
-        }
-        let type = existing.type;
-        if (existing.type !== newField.type) {
-            const [type1, type2] = [existing.type, newField.type].sort();
-            if (type1 === common_schema_1.DATA_TYPE.FLOAT && type2 === common_schema_1.DATA_TYPE.INT) {
-                type = common_schema_1.DATA_TYPE.FLOAT;
-            }
-            else if (type1 === common_schema_1.DATA_TYPE.LOCAL_DATE && type2 === common_schema_1.DATA_TYPE.STRING) {
-                type = common_schema_1.DATA_TYPE.STRING;
-            }
-            else {
-                // Type mismatch! Oj!
-                return newField; // currently just use "latest" type
-            }
-        }
-        // Type is same
-        const minLen = existing.minLen !== undefined
-            ? Math.min(...[existing.minLen, newField.minLen].filter(Boolean))
-            : undefined;
-        const maxLen = existing.maxLen !== undefined
-            ? Math.max(...[existing.maxLen, newField.maxLen].filter(Boolean))
-            : undefined;
-        // todo: recursively merge/compare array/object schemas
-        return (0, js_lib_1._filterNullishValues)({
-            ...newField,
-            type,
-            minLen,
-            maxLen,
-        });
-    }
-    detectType(name, value, level = 1) {
-        // Null
-        if (value === undefined || value === null) {
-            return {
-                name,
-                type: common_schema_1.DATA_TYPE.NULL,
-            };
-        }
-        // String
-        if (typeof value === 'string') {
-            // LocalDate
-            if (LOCAL_DATE_PATTERN.test(value)) {
-                return { name, type: common_schema_1.DATA_TYPE.LOCAL_DATE };
-            }
-            return { name, type: common_schema_1.DATA_TYPE.STRING, minLen: value.length, maxLen: value.length };
-        }
-        // Int, Float
-        if (typeof value === 'number') {
-            // Cannot really detect TIMESTAMP
-            return {
-                name,
-                type: Number.isInteger(value) ? common_schema_1.DATA_TYPE.INT : common_schema_1.DATA_TYPE.FLOAT,
-                minLen: value,
-                maxLen: value,
-            };
-        }
-        // Boolean
-        if (typeof value === 'boolean') {
-            return { name, type: common_schema_1.DATA_TYPE.BOOLEAN };
-        }
-        // Binary
-        if (Buffer.isBuffer(value)) {
-            return { name, type: common_schema_1.DATA_TYPE.BINARY, minLen: value.length, maxLen: value.length };
-        }
-        // Array
-        if (Array.isArray(value)) {
-            return {
-                name,
-                type: common_schema_1.DATA_TYPE.ARRAY,
-                arrayOf: this.detectType('', value[0], level + 1),
-            };
-        }
-        // Object
-        if (typeof value === 'object') {
-            return {
-                name,
-                type: common_schema_1.DATA_TYPE.OBJECT,
-                objectFields: Object.entries(value).map(([k, v]) => this.detectType(k, v, level + 1)),
-            };
-        }
-        return { name, type: common_schema_1.DATA_TYPE.UNKNOWN };
-    }
-    generate() {
-        // set nullability
-        Object.keys(this.fieldByName).forEach(fieldName => {
-            if (!this.nullableFields.has(fieldName)) {
-                this.fieldByName[fieldName].notNull = true;
-            }
-        });
-        const { table, sortedFields } = this.cfg;
-        const fieldNames = Object.keys(this.fieldByName);
-        if (sortedFields)
-            fieldNames.sort(); // mutates
-        // todo: sort object fields too
-        return {
-            table,
-            fields: fieldNames.map(name => this.fieldByName[name]),
-        };
-    }
-    static generateFromRows(cfg, rows = []) {
-        const gen = new CommonSchemaGenerator(cfg);
-        rows.forEach(r => gen.add(r));
-        return gen.generate();
-    }
-}
-exports.CommonSchemaGenerator = CommonSchemaGenerator;

package/src/schema/common.schema.ts

@@ -1,49 +0,0 @@
-// eslint-disable-next-line unused-imports/no-unused-vars
-export interface CommonSchema<ROW = any> {
-  /**
-   * Name of the Table
-   */
-  table: string
-
-  fields: CommonSchemaField[]
-  // can possibly have `meta` with table meta-information
-}
-
-export interface CommonSchemaField {
-  name: string
-  type: DATA_TYPE
-
-  /**
-   * If it's an Array - then parentType should tell "array of what?"
-   */
-  arrayOf?: CommonSchemaField
-
-  /**
-   * If it's an Object - defined the CommonSchemaField of that object
-   */
-  objectFields?: CommonSchemaField[]
-
-  notNull?: boolean
-
-  /**
-   * Applicable to certain fields, e.g String, to be able to autodetect limits for certain Databases
-   */
-  maxLen?: number
-  minLen?: number
-  // avgLen?: number
-}
-
-export enum DATA_TYPE {
-  UNKNOWN = 'UNKNOWN',
-  NULL = 'NULL',
-  STRING = 'STRING',
-  INT = 'INT',
-  FLOAT = 'FLOAT',
-  BOOLEAN = 'BOOLEAN',
-  BINARY = 'BINARY',
-  LOCAL_DATE = 'LOCAL_DATE', // ISO
-  TIMESTAMP = 'TIMESTAMP', // unix timestamp
-  // Semi-structured
-  ARRAY = 'ARRAY',
-  OBJECT = 'OBJECT',
-}

package/src/schema/commonSchemaGenerator.ts

@@ -1,200 +0,0 @@
-import { ErrorMode, _filterNullishValues } from '@naturalcycles/js-lib'
-import { CommonSchema, CommonSchemaField, DATA_TYPE } from './common.schema'
-
-export interface CommonSchemaGeneratorCfg {
-  /**
-   * Name of the Table
-   */
-  table: string
-
-  /**
-   * @default SUPPRESS
-   *
-   * On error (field has multiple types):
-   * if ErrorMode.THROW_IMMEDIATE - will throw on .add()
-   * if ErrorMode.THROW_AGGREGATED - will throw on .generate()
-   */
-  errorMode?: ErrorMode
-
-  /**
-   * @default false
-   * If true - fields will be sorted by name alphabetically (also inside objects)
-   */
-  sortedFields?: boolean
-}
-
-const LOCAL_DATE_PATTERN = new RegExp(/[0-9]{4}-[01][0-9]-[0-3][0-9]/)
-
-/**
- * Class that helps to generate CommonSchema by processing ALL rows through it.
- */
-export class CommonSchemaGenerator<ROW = any> {
-  constructor(public cfg: CommonSchemaGeneratorCfg) {}
-
-  private fieldByName: Record<string, CommonSchemaField> = {}
-  private nullableFields = new Set<string>()
-  // private fieldsWithMultipleTypes: Record<string, DATA_TYPE[]> = {}
-
-  add(row: ROW): void {
-    if (!row) return // safety
-
-    Object.entries(row).forEach(([fieldName, value]) => {
-      this.fieldByName[fieldName] = this.mergeFields(
-        this.fieldByName[fieldName],
-        this.detectType(fieldName, value),
-      )
-
-      if (this.fieldByName[fieldName]!.type === DATA_TYPE.NULL) {
-        this.nullableFields.add(fieldName)
-      }
-    })
-
-    // missing fields
-    Object.keys(this.fieldByName).forEach(fieldName => {
-      if (!(fieldName in row)) {
-        // missing field!
-        this.nullableFields.add(fieldName)
-      }
-    })
-  }
-
-  private mergeFields(
-    existing: CommonSchemaField | undefined,
-    newField: CommonSchemaField,
-  ): CommonSchemaField {
-    if (!existing) return newField
-
-    if (newField.type === DATA_TYPE.UNKNOWN || newField.type === DATA_TYPE.NULL) {
-      return {
-        ...existing,
-      }
-    }
-
-    if (existing.type === DATA_TYPE.UNKNOWN || existing.type === DATA_TYPE.NULL) {
-      return {
-        ...newField,
-      }
-    }
-
-    let type = existing.type
-
-    if (existing.type !== newField.type) {
-      const [type1, type2] = [existing.type, newField.type].sort()
-      if (type1 === DATA_TYPE.FLOAT && type2 === DATA_TYPE.INT) {
-        type = DATA_TYPE.FLOAT
-      } else if (type1 === DATA_TYPE.LOCAL_DATE && type2 === DATA_TYPE.STRING) {
-        type = DATA_TYPE.STRING
-      } else {
-        // Type mismatch! Oj!
-        return newField // currently just use "latest" type
-      }
-    }
-
-    // Type is same
-    const minLen =
-      existing.minLen !== undefined
-        ? Math.min(...[existing.minLen, newField.minLen!].filter(Boolean))
-        : undefined
-    const maxLen =
-      existing.maxLen !== undefined
-        ? Math.max(...[existing.maxLen, newField.maxLen!].filter(Boolean))
-        : undefined
-
-    // todo: recursively merge/compare array/object schemas
-
-    return _filterNullishValues({
-      ...newField,
-      type,
-      minLen,
-      maxLen,
-    })
-  }
-
-  private detectType(name: string, value: any, level = 1): CommonSchemaField {
-    // Null
-    if (value === undefined || value === null) {
-      return {
-        name,
-        type: DATA_TYPE.NULL,
-      }
-    }
-
-    // String
-    if (typeof value === 'string') {
-      // LocalDate
-      if (LOCAL_DATE_PATTERN.test(value)) {
-        return { name, type: DATA_TYPE.LOCAL_DATE }
-      }
-
-      return { name, type: DATA_TYPE.STRING, minLen: value.length, maxLen: value.length }
-    }
-
-    // Int, Float
-    if (typeof value === 'number') {
-      // Cannot really detect TIMESTAMP
-      return {
-        name,
-        type: Number.isInteger(value) ? DATA_TYPE.INT : DATA_TYPE.FLOAT,
-        minLen: value,
-        maxLen: value,
-      }
-    }
-
-    // Boolean
-    if (typeof value === 'boolean') {
-      return { name, type: DATA_TYPE.BOOLEAN }
-    }
-
-    // Binary
-    if (Buffer.isBuffer(value)) {
-      return { name, type: DATA_TYPE.BINARY, minLen: value.length, maxLen: value.length }
-    }
-
-    // Array
-    if (Array.isArray(value)) {
-      return {
-        name,
-        type: DATA_TYPE.ARRAY,
-        arrayOf: this.detectType('', value[0], level + 1),
-      }
-    }
-
-    // Object
-    if (typeof value === 'object') {
-      return {
-        name,
-        type: DATA_TYPE.OBJECT,
-        objectFields: Object.entries(value).map(([k, v]) => this.detectType(k, v, level + 1)),
-      }
-    }
-
-    return { name, type: DATA_TYPE.UNKNOWN }
-  }
-
-  generate(): CommonSchema<ROW> {
-    // set nullability
-    Object.keys(this.fieldByName).forEach(fieldName => {
-      if (!this.nullableFields.has(fieldName)) {
-        this.fieldByName[fieldName]!.notNull = true
-      }
-    })
-
-    const { table, sortedFields } = this.cfg
-
-    const fieldNames = Object.keys(this.fieldByName)
-    if (sortedFields) fieldNames.sort() // mutates
-
-    // todo: sort object fields too
-
-    return {
-      table,
-      fields: fieldNames.map(name => this.fieldByName[name]!),
-    }
-  }
-
-  static generateFromRows<ROW>(cfg: CommonSchemaGeneratorCfg, rows: ROW[] = []): CommonSchema<ROW> {
-    const gen = new CommonSchemaGenerator(cfg)
-    rows.forEach(r => gen.add(r))
-    return gen.generate()
-  }
-}