pqb 0.67.1 → 0.67.2

package/dist/index.d.ts

@@ -4455,6 +4455,7 @@ declare class QueryScope {
 type DeleteMethodsNames = 'delete';
 type DeleteArgs<T extends PickQueryHasWhere> = T['__hasWhere'] extends true ? EmptyTuple : [never];
 type DeleteResult<T extends PickQueryHasSelectResultReturnType> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
+interface DeleteSelf extends PickQueryHasSelectHasWhereResultReturnType, Query.Pick.IsNotReadOnly {}
 declare const _queryDelete: <T extends PickQueryHasSelectResultReturnType>(query: T) => DeleteResult<T>;
 declare class QueryDelete {
   /**
@@ -4516,10 +4517,10 @@ declare class QueryDelete {
    *   .from('b');
    * ```
    */
-  delete<T extends PickQueryHasSelectHasWhereResultReturnType>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
+  delete<T extends DeleteSelf>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T>;
 }
 type SoftDeleteOption<Shape extends Column.QueryColumns> = true | keyof Shape;
-interface QueryWithSoftDelete extends PickQueryResult, PickQueryReturnType, PickQueryHasSelect, PickQueryHasWhere {
+interface QueryWithSoftDelete extends PickQueryResult, PickQueryReturnType, PickQueryHasSelect, PickQueryHasWhere, Query.Pick.IsNotReadOnly {
   __scopes: NonDeletedScope;
 }
 interface NonDeletedScope {
@@ -4820,6 +4821,7 @@ interface QueryInternal<SinglePrimaryKey = any, UniqueColumns = any, UniqueColum
   snakeCase?: boolean;
   noPrimaryKey: boolean;
   comment?: string;
+  readOnly?: boolean;
   primaryKeys?: string[];
   singlePrimaryKey: SinglePrimaryKey;
   uniqueColumns: UniqueColumns;
@@ -4909,6 +4911,10 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
    * Table comment, for migrations generator
    */
   comment?: string;
+  /**
+   * Disallow runtime create, update, and delete operations.
+   */
+  readOnly?: true | undefined;
   /**
    * Computed SQL or JS columns definitions
    */
@@ -4919,10 +4925,10 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
   nowSQL?: string;
 }
 type DbTableOptionScopes<Table extends string | undefined, Shape extends Column.QueryColumns, Keys extends string = string> = { [K in Keys]: (q: ScopeArgumentQuery<Table, Shape>) => IsQuery };
-interface QueryBuilder extends Query {
+interface QueryBuilder extends Query.NotReadOnlyQuery {
   returnType: undefined;
 }
-declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends Column.QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject, DefaultSelect extends keyof Shape = keyof Shape> extends QueryMethods<ColumnTypes> implements Query {
+declare class Db<Table extends string | undefined = undefined, Shape extends Column.QueryColumnsInit = Column.QueryColumnsInit, PrimaryKeys = never, UniqueColumns = never, UniqueColumnTuples = never, UniqueConstraints = never, ColumnTypes = DefaultColumnTypes<ColumnSchemaConfig>, ShapeWithComputed extends Column.QueryColumnsInit = Shape, Scopes extends RecordUnknown | undefined = EmptyObject, DefaultSelect extends keyof Shape = keyof Shape, ReadOnly extends true | undefined = undefined> extends QueryMethods<ColumnTypes> implements Query {
   adapterNotInTransaction: Adapter;
   qb: QueryBuilder;
   table: Table;
@@ -4931,6 +4937,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   __isQuery: true;
   __as: Table & string;
   __selectable: SelectableFromShape<ShapeWithComputed, Table>;
+  readOnly: ReadOnly;
   __hasSelect: boolean;
   __hasWhere: boolean;
   __defaults: { [K in { [K in keyof Shape]: unknown extends Shape[K]['data']['default'] ? never : K }[keyof Shape]]: true };
@@ -5020,9 +5027,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   queryArrays<R extends any[] = any[]>(...args: SQLQueryArgs): Promise<QueryResult<R>>;
 }
 interface DbTableConstructor<ColumnTypes> {
-  <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options>, ColumnsShape.DefaultSelectKeys<Shape>> & {
-    ko: Shape;
-  };
+  <Table extends string, Shape extends Column.QueryColumnsInit, Data extends MaybeArray<TableDataItem>, Options extends DbTableOptions<ColumnTypes, Table, Shape>>(table: Table, shape?: ((t: ColumnTypes) => Shape) | Shape, tableData?: TableDataFn<Shape, Data>, options?: Options): Db<Table, Shape, keyof ShapeColumnPrimaryKeys<Shape> extends never ? never : ShapeColumnPrimaryKeys<Shape>, ShapeUniqueColumns<Shape> | TableDataItemsUniqueColumns<Shape, Data>, TableDataItemsUniqueColumnTuples<Shape, Data>, UniqueConstraints<Shape> | TableDataItemsUniqueConstraints<Data>, ColumnTypes, Shape & ComputedColumnsFromOptions<Options['computed']>, MapTableScopesOption<Options>, ColumnsShape.DefaultSelectKeys<Shape>, Options['readOnly'] extends true ? true : undefined>;
 }
 interface DbSqlMethod<ColumnTypes> {
   <T>(...args: StaticSQLArgs): RawSql<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
@@ -7486,13 +7491,12 @@ declare class QueryCreateFrom {
    */
   insertForEachFrom<T extends CreateSelf>(this: T, query: IsQuery): InsertManyFromResult<T>;
 }
-interface CreateSelf extends IsQuery, PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType {}
+interface CreateSelf extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType, Query.Pick.IsNotReadOnly {}
 type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
 type CreateDataWithDefaults<T extends CreateSelf, Defaults extends PropertyKey> = { [K in keyof T['inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['inputType'] ? CreateColumn<T, K> : never };
 type CreateDataWithDefaultsForRelations<T extends CreateSelf, Defaults extends keyof T['inputType'], OmitFKeys extends PropertyKey> = { [K in keyof T['inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K> } & { [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K> };
 type CreateColumn<T extends CreateSelf, K extends keyof T['inputType']> = T['inputType'][K] | ((q: T) => QueryOrExpression<T['inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateBelongsToData<T> & T['relations'][keyof T['relations']]['optionalDataForCreate'];
-type CreateBelongsToData<T extends CreateSelf> = [T['relations'][keyof T['relations']]['dataForCreate']] extends [never] ? EmptyObject : CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
+type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']> & T['relations'][keyof T['relations']]['optionalDataForCreate'];
 type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['__defaults'] ? { [P in Exclude<Union['columns'] & keyof T['inputType'], keyof T['__defaults']>]: CreateColumn<T, P> } & { [P in keyof T['__defaults'] & Union['columns']]?: CreateColumn<T, P> } & Partial<Union['nested']> : { [P in Union['columns'] & keyof T['inputType']]: CreateColumn<T, P> } | Union['nested']) => void : never) extends ((u: infer Obj) => void) ? Obj : never;
 type CreateResult<T extends CreateSelf, Data> = T extends {
   isCount: true;
@@ -7877,23 +7881,24 @@ declare class OnConflictQueryBuilder<T extends CreateSelf, Arg extends OnConflic
     except: keyof T['shape'] | (keyof T['shape'])[];
   }): T;
 }
-interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryInputType, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere {}
-type UpdateData<T extends UpdateSelf> = EmptyObject extends T['relations'] ? { [K in keyof T['inputType']]?: UpdateColumn<T, K> } : { [K in keyof T['inputType'] | keyof T['relations']]?: K extends keyof T['inputType'] ? UpdateColumn<T, K> : UpdateRelationData<T, T['relations'][K]> };
-type UpdateColumn<T extends UpdateSelf, Key extends keyof T['inputType']> = T['inputType'][Key] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never }) => QueryOrExpression<T['inputType'][Key]>);
-type UpdateRelationData<T extends UpdateSelf, Rel extends RelationConfigBase> = T['returnType'] extends undefined | 'all' ? Rel['dataForUpdate'] : Rel['dataForUpdateOne'];
+interface UpdateSelf extends PickQuerySelectable, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryInputType, PickQueryAs, PickQueryHasSelect, PickQueryHasWhere, Query.Pick.IsNotReadOnly {}
+type UpdateData<T extends UpdateSelf> = { [K in keyof T['inputType'] | keyof T['relations']]?: K extends keyof T['inputType'] ? T['inputType'][K] | ((q: { [K in keyof T['relations'] | keyof T]: K extends keyof T['relations'] ? T['relations'][K]['query'] : K extends keyof T ? T[K] : never }) => QueryOrExpression<T['inputType'][K]>) : T['returnType'] extends undefined | 'all' ? T['relations'][K]['dataForUpdate'] : T['relations'][K]['dataForUpdateOne'] };
 type UpdateArg<T extends UpdateSelf> = T['__hasWhere'] extends true ? UpdateData<T> : 'Update statement must have where conditions. To update all prefix `update` with `all()`';
 type UpdateResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsRowCountMany<T> : SetQueryReturnsRowCount<T>;
 type NumericColumns<T extends UpdateSelf> = { [K in keyof T['inputType']]: Exclude<T['shape'][K]['queryType'], string> extends number | bigint | null ? K : never }[keyof T['inputType']];
 type ChangeCountArg<T extends UpdateSelf> = NumericColumns<T> | { [K in NumericColumns<T>]?: T['shape'][K]['type'] extends number | null ? number : number | string | bigint };
-type UpdateManyBySelf = UpdateSelf & PickQueryResultReturnTypeUniqueColumns & PickQueryUniqueProperties;
-type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends {
-  data: {
-    primaryKey: string;
+interface UpdateManyBySelf extends UpdateSelf {
+  internal: {
+    uniqueColumns: unknown;
+    uniqueColumnNames: unknown;
+    uniqueColumnTuples: unknown;
+    uniqueConstraints: unknown;
   };
-} ? K : never]: T['shape'][K]['queryType'] | Expression } & { [P in keyof T['inputType']]?: T['inputType'][P] | Expression })[];
+}
+type UpdateManyData<T extends UpdateSelf> = ({ [K in keyof T['shape'] as T['shape'][K] extends Column.Modifiers.IsPrimaryKey<string> ? K : never]: T['shape'][K]['queryType'] | Expression } & { [P in keyof T['inputType']]?: T['inputType'][P] | Expression })[];
 type UpdateManyByKeys<T extends UpdateManyBySelf> = T['internal']['uniqueColumnNames'] | T['internal']['uniqueColumnTuples'];
-type UpdateManyByKeyColumns<Keys> = Keys extends string ? Keys : Keys extends unknown[] ? Keys[number] & string : never;
-type UpdateManyByData<T extends UpdateSelf, K extends string> = ({ [P in K & keyof T['inputType']]-?: T['inputType'][P] } & { [P in keyof T['inputType'] as P extends K ? never : P]?: T['inputType'][P] | Expression })[];
+type UpdateManyByKeyColumns<K> = K extends string[] ? K[number] : K;
+type UpdateManyByData<T extends UpdateSelf, K> = ({ [P in K & keyof T['inputType']]: T['inputType'][P] } & { [P in keyof T['inputType']]?: P extends K ? T['inputType'][P] : T['inputType'][P] | Expression })[];
 type UpdateManyResult<T extends UpdateSelf> = T['__hasSelect'] extends true ? T['returnType'] extends 'one' | 'oneOrThrow' ? SetQueryReturnsAllResult<T, T['result']> : T['returnType'] extends 'value' | 'valueOrThrow' ? SetQueryReturnsPluckColumnResult<T, T['result']> : SetQueryResult<T, T['result']> : SetQueryReturnsRowCountMany<T>;
 declare const _queryUpdate: <T extends UpdateSelf>(updateSelf: T, arg: UpdateArg<T>) => UpdateResult<T>;
 declare const _queryUpdateOrThrow: <T extends UpdateSelf>(q: T, arg: UpdateArg<T>) => UpdateResult<T>;
@@ -8327,7 +8332,7 @@ declare class QueryUpdate {
    * ]);
    * ```
    */
-  updateManyBy<T extends UpdateManyBySelf, Keys extends UpdateManyByKeys<T>, K extends string = UpdateManyByKeyColumns<Keys>>(this: T, keys: Keys, data: UpdateManyByData<T, K>): UpdateManyResult<T> & QueryHasWhere;
+  updateManyBy<T extends UpdateManyBySelf, Keys extends UpdateManyByKeys<T>, K = UpdateManyByKeyColumns<Keys>>(this: T, keys: Keys, data: UpdateManyByData<T, K>): UpdateManyResult<T> & QueryHasWhere;
   /**
    * Same as {@link updateManyBy}, but skips records with no matching key rather than throwing.
    *
@@ -8338,7 +8343,7 @@ declare class QueryUpdate {
    * ]);
    * ```
    */
-  updateManyByOptional<T extends UpdateManyBySelf, Keys extends UpdateManyByKeys<T>, K extends string = UpdateManyByKeyColumns<Keys>>(this: T, keys: Keys, data: UpdateManyByData<T, K>): UpdateManyResult<T> & QueryHasWhere;
+  updateManyByOptional<T extends UpdateManyBySelf, Keys extends UpdateManyByKeys<T>, K = UpdateManyByKeyColumns<Keys>>(this: T, keys: Keys, data: UpdateManyByData<T, K>): UpdateManyResult<T> & QueryHasWhere;
 }
 declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSchema extends Schema['type'] = ReturnType<Schema['never']>> extends Column<Schema, unknown, InputSchema, OperatorsAny> {
   dataType: string;
@@ -9338,7 +9343,7 @@ type UpsertData<T extends UpsertThis, Update extends UpdateData<T>> = {
   data: Update;
   create: UpsertCreate<keyof Update, CreateData<T>> | ((update: Update) => UpsertCreate<keyof Update, CreateData<T>>);
 };
-declare const _queryUpsert: (q: Query, data: UpsertData<UpsertThis, UpdateData<Query>>) => Query;
+declare const _queryUpsert: (q: Query, data: UpsertData<UpsertThis, UpdateData<UpdateSelf>>) => Query;
 declare class QueryUpsert {
   /**
    * `upsert` tries to update a single record, and then it creates the record if it doesn't yet exist.
@@ -9725,7 +9730,7 @@ declare class QueryTruncate {
    *
    * @param options - truncate options, may have `cascade: true` and `restartIdentity: true`
    */
-  truncate<T>(this: T, options?: {
+  truncate<T extends Query.Pick.IsNotReadOnly>(this: T, options?: {
     restartIdentity?: boolean;
     cascade?: boolean;
   }): SetQueryReturnsVoid<T>;
@@ -10281,8 +10286,12 @@ interface Query extends IsQuery, PickQueryTable, PickQueryShape, PickQuerySelect
   relations: RelationsBase;
   relationQueries: IsQueries;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError;
+  readOnly: true | undefined;
 }
 declare namespace Query {
+  interface NotReadOnlyQuery extends Query {
+    readOnly: undefined;
+  }
   namespace Order {
     type Arg<T extends Order.ArgThis> = Order.Arg<T>;
     type Args<T extends Order.ArgThis> = Order.Args<T>;
@@ -10294,6 +10303,9 @@ declare namespace Query {
       };
       returnType: 'value' | 'valueOrThrow';
     }
+    interface IsNotReadOnly {
+      readOnly: undefined;
+    }
   }
 }
 type SelectableOfType<T extends PickQuerySelectable, Type> = { [K in keyof T['__selectable']]: T['__selectable'][K]['column']['type'] extends Type | null ? K : never }[keyof T['__selectable']];
@@ -10364,7 +10376,7 @@ interface RelationConfigBase extends IsQuery {
   modifyRelatedQuery?(relatedQuery: IsQuery): (query: IsQuery) => void;
   maybeSingle: PickQuerySelectableReturnType;
   omitForeignKeyInCreate: PropertyKey;
-  dataForCreate?: RelationConfigDataForCreate;
+  dataForCreate: RelationConfigDataForCreate | undefined;
   optionalDataForCreate: unknown;
   dataForUpdate: unknown;
   dataForUpdateOne: unknown;

package/dist/index.js

@@ -3501,6 +3501,11 @@ var NestedSqlSessionError = class extends OrchidOrmInternalError {
 		super(query, "Cannot nest SQL session scopes. Outer scope already has role or setConfig defined.");
 	}
 };
+var CannotMutateReadOnlyTableError = class extends OrchidOrmInternalError {
+	constructor(query) {
+		super(query, "Cannot mutate a readonly table.");
+	}
+};
 const escape = (value, migration, nested) => {
 	const type = typeof value;
 	if (type === "number" || type === "bigint") return String(value);
@@ -5183,6 +5188,9 @@ const throwIfNoWhere = (q, method) => {
 const throwIfJoinLateral = (q, method) => {
 	if (q.q.join?.some((x) => Array.isArray(x) || "s" in x.args && x.args.s)) throw new OrchidOrmInternalError(q, `Cannot join a complex query in ${method}`);
 };
+const throwIfReadOnly = (query) => {
+	if (query.internal.readOnly) throw new CannotMutateReadOnlyTableError(query);
+};
 const throwOnReadOnlyUpdate = (query, column, key) => {
 	if (column.data.appReadOnly || column.data.readOnly) throw new OrchidOrmInternalError(query, "Trying to update a readonly column", { column: key });
 };
@@ -8480,6 +8488,7 @@ var AggregateMethods = class {
 * @param data - optionally passed custom data when creating a single record.
 */
 const insertFrom = (query, from, many, queryMany, data) => {
+	throwIfReadOnly(query);
 	const ctx = createCtx();
 	const obj = data && (Array.isArray(data) ? handleManyData(query, data, ctx) : handleOneData(query, data, ctx));
 	return insert(query, {
@@ -8935,17 +8944,21 @@ const insert = (self, { columns, insertFrom, values }, many, queryMany) => {
 	return self;
 };
 const _queryCreate = (q, data) => {
+	throwIfReadOnly(q);
 	createSelect(q);
 	return _queryInsert(q, data);
 };
 const _queryInsert = (query, data) => {
+	throwIfReadOnly(query);
 	return insert(query, handleOneData(query, data, createCtx()));
 };
 const _queryCreateMany = (q, data) => {
+	throwIfReadOnly(q);
 	createSelect(q);
 	return _queryInsertMany(q, data);
 };
 const _queryInsertMany = (q, data) => {
+	throwIfReadOnly(q);
 	let result = insert(q, handleManyData(q, data, createCtx()), true);
 	if (!data.length) result = result.none();
 	return result;
@@ -11294,6 +11307,7 @@ var QueryGet = class {
 	}
 };
 const _queryDelete = (query) => {
+	throwIfReadOnly(query);
 	const q = query.q;
 	if (!q.select) {
 		if (q.returnType === "oneOrThrow" || q.returnType === "valueOrThrow") q.throwOnNotFound = true;
@@ -11477,6 +11491,7 @@ var RefExpression = class extends Expression {
 };
 const _queryUpdateMany = (self, primaryKeys, data, strict) => {
 	const query = self;
+	throwIfReadOnly(query);
 	const { q } = query;
 	const { shape } = q;
 	q.type = "update";
@@ -11496,6 +11511,7 @@ const _queryUpdateMany = (self, primaryKeys, data, strict) => {
 	return query;
 };
 const _queryChangeCounter = (self, op, data) => {
+	throwIfReadOnly(self);
 	const q = self.q;
 	q.type = "update";
 	if (!q.select) {
@@ -11528,6 +11544,7 @@ const _queryChangeCounter = (self, op, data) => {
 };
 const _queryUpdate = (updateSelf, arg) => {
 	const query = updateSelf;
+	throwIfReadOnly(query);
 	const { q } = query;
 	q.type = "update";
 	const set = { ...arg };
@@ -11855,6 +11872,7 @@ var QueryUpdate = class {
 	*/
 	updateFrom(arg, ...args) {
 		const q = _clone(this);
+		throwIfReadOnly(q);
 		const joinArgs = _joinReturningArgs(q, true, arg, args, true);
 		if (!joinArgs) return _queryNone(q);
 		joinArgs.u = true;
@@ -13123,6 +13141,7 @@ var QueryTruncate = class {
 	* @param options - truncate options, may have `cascade: true` and `restartIdentity: true`
 	*/
 	truncate(options) {
+		throwIfReadOnly(this);
 		const query = Object.create(_clone(this));
 		query.toSQL = () => makeTruncateSql(query, options);
 		return _queryExec(query);
@@ -13786,6 +13805,7 @@ var Db = class extends QueryMethods {
 			snakeCase: options.snakeCase,
 			noPrimaryKey: options.noPrimaryKey === "ignore",
 			comment: options.comment,
+			readOnly: options.readOnly,
 			nowSQL: options.nowSQL,
 			tableData,
 			selectAllCount