orchid-orm 1.18.3 → 1.20.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, QueryData, QueryBase, DbTableOptionScopes, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, MapTableScopesOption, QueryData, QueryBase, DbTableOptionScopes, DefaultSchemaConfig, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export * from 'pqb';
-import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
+import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnSchemaConfig } from 'orchid-core';
 
 type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
     scope?: ScopeFn<Related, Scope>;
@@ -344,7 +344,7 @@ type TableClass<T extends Table = Table> = {
 type TableClasses = Record<string, TableClass>;
 type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
     [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
-} : T['columns'], T['scopes']> & {
+} : T['columns'], MapTableScopesOption<T['scopes'], T['softDelete']>> & {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
@@ -365,6 +365,7 @@ type Table = {
      */
     computed?: ComputedColumnsBase<never>;
     scopes?: CoreQueryScopes;
+    readonly softDelete?: true | string;
 };
 type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
 type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
@@ -373,7 +374,6 @@ type Updateable<T extends Table> = Partial<Insertable<T>>;
 type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
 type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
 type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
-type SchemaProviderBase = any;
 interface BaseTableInstance<ColumnTypes> {
     table: string;
     columns: ColumnsShapeBase;
@@ -529,23 +529,25 @@ interface BaseTableInstance<ColumnTypes> {
     afterDelete: AfterSelectableHookMethod;
     afterDeleteCommit: AfterSelectableHookMethod;
 }
-interface BaseTableClass<ColumnTypes, SchemaProvider extends SchemaProviderBase> {
+interface BaseTableClass<SchemaConfig extends ColumnSchemaConfig, ColumnTypes> {
     nowSQL: string | undefined;
     exportAs: string;
-    schema: SchemaProvider;
     getFilePath(): string;
     new (): BaseTableInstance<ColumnTypes>;
     instance(): BaseTableInstance<ColumnTypes>;
+    inputSchema: SchemaConfig['inputSchema'];
+    outputSchema: SchemaConfig['outputSchema'];
+    querySchema: SchemaConfig['querySchema'];
 }
-declare function createBaseTable<SchemaProvider extends SchemaProviderBase, ColumnTypes = DefaultColumnTypes>({ columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, schemaProvider: schemaProviderArg, }?: {
-    columnTypes?: ColumnTypes | ((t: DefaultColumnTypes) => ColumnTypes);
+declare function createBaseTable<SchemaConfig extends ColumnSchemaConfig = DefaultSchemaConfig, ColumnTypes = DefaultColumnTypes<SchemaConfig>>({ schemaConfig, columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, }?: {
+    schemaConfig?: SchemaConfig;
+    columnTypes?: ColumnTypes | ((t: DefaultColumnTypes<SchemaConfig>) => ColumnTypes);
     snakeCase?: boolean;
     filePath?: string;
     nowSQL?: string;
     exportAs?: string;
     language?: string;
-    schemaProvider?: SchemaProvider;
-}): BaseTableClass<ColumnTypes, SchemaProvider>;
+}): BaseTableClass<SchemaConfig, ColumnTypes>;
 
 type QueryMethods<T extends Query> = Record<string, (q: T, ...args: any[]) => any>;
 type QueryOne<T extends Query> = SetQueryReturns<T, Exclude<QueryReturnType, 'all'>>;

package/dist/index.js

@@ -5,25 +5,18 @@ var orchidCore = require('orchid-core');
 var node_async_hooks = require('node:async_hooks');
 
 function createBaseTable({
+  schemaConfig = pqb.defaultSchemaConfig,
   columnTypes: columnTypesArg,
   snakeCase,
   filePath: filePathArg,
   nowSQL,
   exportAs = "BaseTable",
-  language,
-  schemaProvider: schemaProviderArg
+  language
 } = {}) {
   var _a;
-  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(
-    pqb.columnTypes
-  ) : columnTypesArg || pqb.columnTypes;
+  const columnTypes = typeof columnTypesArg === "function" ? columnTypesArg(pqb.makeColumnTypes(schemaConfig)) : columnTypesArg || pqb.makeColumnTypes(pqb.defaultSchemaConfig);
   const filePathOrStack = filePathArg || orchidCore.getStackTrace();
   let filePath;
-  function schemaProvider() {
-    const schema = schemaProviderArg.call(this);
-    this.schema = () => schema;
-    return schema;
-  }
   const base = (_a = class {
     constructor() {
       this.snakeCase = snakeCase;
@@ -31,6 +24,21 @@ function createBaseTable({
       this.q = {};
       this.language = language;
     }
+    static inputSchema() {
+      return this._inputSchema === void 0 ? this._inputSchema = schemaConfig.inputSchema.call(this) : this._inputSchema;
+    }
+    static outputSchema() {
+      return this._outputSchema === void 0 ? this._outputSchema = schemaConfig.outputSchema.call(this) : this._outputSchema;
+    }
+    static querySchema() {
+      return this._querySchema === void 0 ? this._querySchema = schemaConfig.querySchema.call(this) : this._querySchema;
+    }
+    static updateSchema() {
+      return this._updateSchema === void 0 ? this._updateSchema = schemaConfig.updateSchema.call(this) : this._updateSchema;
+    }
+    static pkeySchema() {
+      return this._pkeySchema === void 0 ? this._pkeySchema = schemaConfig.pkeySchema.call(this) : this._pkeySchema;
+    }
     static getFilePath() {
       if (filePath)
         return filePath;
@@ -77,7 +85,7 @@ function createBaseTable({
           }
         }
       }
-      return shape;
+      return this.constructor.prototype.columns = shape;
     }
     setComputed(computed) {
       return computed;
@@ -113,7 +121,7 @@ function createBaseTable({
         options
       };
     }
-  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a.schema = schemaProvider, _a);
+  }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a);
   orchidCore.applyMixins(base, [pqb.QueryHooks]);
   base.prototype.types = columnTypes;
   return base;
@@ -226,8 +234,8 @@ const joinQueryChainingHOF = (reverseJoin, joinQuery) => (joiningQuery, baseQuer
 };
 
 class BelongsToVirtualColumn extends pqb.VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$3(this.state);
@@ -304,7 +312,11 @@ const makeBelongsToMethod = (relation, relationName, query) => {
     method(params) {
       return query.where(makeWhere(params));
     },
-    virtualColumn: new BelongsToVirtualColumn(relationName, state),
+    virtualColumn: new BelongsToVirtualColumn(
+      pqb.defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)
@@ -505,8 +517,8 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 class HasOneVirtualColumn extends pqb.VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$2(state);
@@ -603,7 +615,11 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
       }
       return query.where(values)._defaults(values);
     },
-    virtualColumn: new HasOneVirtualColumn(relationName, state),
+    virtualColumn: new HasOneVirtualColumn(
+      pqb.defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
@@ -749,8 +765,8 @@ var __spreadValues$4 = (a, b) => {
   return a;
 };
 class HasManyVirtualColumn extends pqb.VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert$1(state);
@@ -851,7 +867,11 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
       }
       return query.where(values)._defaults(values);
     },
-    virtualColumn: new HasManyVirtualColumn(relationName, state),
+    virtualColumn: new HasManyVirtualColumn(
+      pqb.defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(
       reverseJoin,
       (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
@@ -1042,8 +1062,8 @@ var __spreadValues$3 = (a, b) => {
 };
 var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 class HasAndBelongsToManyVirtualColumn extends pqb.VirtualColumn {
-  constructor(key, state) {
-    super();
+  constructor(schema, key, state) {
+    super(schema);
     this.key = key;
     this.state = state;
     this.nestedInsert = nestedInsert(state);
@@ -1112,7 +1132,9 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
   baseQuery.table = joinTable;
   const shape = {};
   for (let i = 0; i < len; i++) {
-    shape[foreignKeys[i]] = removeColumnName(table.shape[primaryKeys[i]]);
+    shape[foreignKeys[i]] = removeColumnName(
+      table.shape[primaryKeys[i]]
+    );
   }
   for (let i = 0; i < throughLen; i++) {
     shape[throughForeignKeys[i]] = removeColumnName(
@@ -1176,7 +1198,11 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
         return q._where(where);
       });
     },
-    virtualColumn: new HasAndBelongsToManyVirtualColumn(relationName, state),
+    virtualColumn: new HasAndBelongsToManyVirtualColumn(
+      pqb.defaultSchemaConfig,
+      relationName,
+      state
+    ),
     joinQuery: joinQueryChainingHOF(reverseJoin, (joiningQuery, baseQuery2) => {
       const joined = joinQuery(
         joiningQuery,
@@ -1735,7 +1761,7 @@ const orchidORM = (_a, tables) => {
       void 0,
       void 0,
       pqb.anyShape,
-      pqb.columnTypes,
+      pqb.makeColumnTypes(pqb.defaultSchemaConfig),
       transactionStorage,
       commonOptions
     );
@@ -1760,7 +1786,8 @@ const orchidORM = (_a, tables) => {
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
       schema: table.schema,
       language: table.language,
-      scopes: table.scopes
+      scopes: table.scopes,
+      softDelete: table.softDelete
     });
     if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";