@clioplaylists/clio 0.1.0

package/dist/dataplane/server/db/db.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const kysely_1 = require("kysely");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_events_1 = __importDefault(require("node:events"));
+const pg_1 = require("pg");
+const logger_1 = require("../../../logger");
+const migrations = __importStar(require("./migrations"));
+const provider_1 = require("./migrations/provider");
+class Database {
+    constructor(opts, instances) {
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: opts
+        });
+        Object.defineProperty(this, "pool", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "migrator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "txEvt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new node_events_1.default()
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        // if instances are provided, use those
+        if (instances) {
+            this.db = instances.db;
+            this.pool = instances.pool;
+            this.migrator = instances.migrator;
+            return;
+        }
+        // else create a pool & connect
+        const { schema, url } = opts;
+        const pool = opts.pool ??
+            new pg_1.Pool({
+                connectionString: url,
+                max: opts.poolSize,
+                maxUses: opts.poolMaxUses,
+                idleTimeoutMillis: opts.poolIdleTimeoutMs,
+            });
+        // Select count(*) and other pg bigints as js integer
+        pg_1.types.setTypeParser(pg_1.types.builtins.INT8, (n) => parseInt(n, 10));
+        // Setup schema usage, primarily for test parallelism (each test suite runs in its own pg schema)
+        if (schema && !/^[a-z_]+$/i.test(schema)) {
+            throw new Error(`Postgres schema must only contain [A-Za-z_]: ${schema}`);
+        }
+        pool.on('error', onPoolError);
+        pool.on('connect', (client) => {
+            client.on('error', onClientError);
+            // Used for trigram indexes, e.g. on actor search
+            client.query('SET pg_trgm.word_similarity_threshold TO .4;');
+            if (schema) {
+                // Shared objects such as extensions will go in the public schema
+                client.query(`SET search_path TO "${schema}",public;`);
+            }
+        });
+        this.pool = pool;
+        this.db = new kysely_1.Kysely({
+            dialect: new kysely_1.PostgresDialect({ pool }),
+        });
+        this.migrator = new kysely_1.Migrator({
+            db: this.db,
+            migrationTableSchema: opts.schema,
+            provider: new provider_1.CtxMigrationProvider(migrations, 'pg'),
+        });
+    }
+    get schema() {
+        return this.opts.schema;
+    }
+    async transaction(fn) {
+        const leakyTxPlugin = new LeakyTxPlugin();
+        const { dbTxn, txRes } = await this.db
+            .withPlugin(leakyTxPlugin)
+            .transaction()
+            .execute(async (txn) => {
+            const dbTxn = new Database(this.opts, {
+                db: txn,
+                pool: this.pool,
+                migrator: this.migrator,
+            });
+            const txRes = await fn(dbTxn)
+                .catch(async (err) => {
+                leakyTxPlugin.endTx();
+                // ensure that all in-flight queries are flushed & the connection is open
+                await dbTxn.db.getExecutor().provideConnection(noopAsync);
+                throw err;
+            })
+                .finally(() => leakyTxPlugin.endTx());
+            return { dbTxn, txRes };
+        });
+        dbTxn?.txEvt.emit('commit');
+        return txRes;
+    }
+    get isTransaction() {
+        return this.db.isTransaction;
+    }
+    assertTransaction() {
+        (0, node_assert_1.default)(this.isTransaction, 'Transaction required');
+    }
+    assertNotTransaction() {
+        (0, node_assert_1.default)(!this.isTransaction, 'Cannot be in a transaction');
+    }
+    onCommit(fn) {
+        this.assertTransaction();
+        this.txEvt.once('commit', fn);
+    }
+    async migrateToOrThrow(migration) {
+        if (this.schema) {
+            await this.db.schema.createSchema(this.schema).ifNotExists().execute();
+        }
+        const { error, results } = await this.migrator.migrateTo(migration);
+        if (error) {
+            throw error;
+        }
+        if (!results) {
+            throw new Error('An unknown failure occurred while migrating');
+        }
+        return results;
+    }
+    async migrateToLatestOrThrow() {
+        if (this.schema) {
+            await this.db.schema.createSchema(this.schema).ifNotExists().execute();
+        }
+        const { error, results } = await this.migrator.migrateToLatest();
+        if (error) {
+            throw error;
+        }
+        if (!results) {
+            throw new Error('An unknown failure occurred while migrating');
+        }
+        return results;
+    }
+    async close() {
+        if (this.destroyed)
+            return;
+        await this.db.destroy();
+        this.destroyed = true;
+    }
+}
+exports.Database = Database;
+exports.default = Database;
+const onPoolError = (err) => logger_1.dbLogger.error({ err }, 'db pool error');
+const onClientError = (err) => logger_1.dbLogger.error({ err }, 'db client error');
+// utils
+// -------
+class LeakyTxPlugin {
+    constructor() {
+        Object.defineProperty(this, "txOver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    endTx() {
+        this.txOver = true;
+    }
+    transformQuery(args) {
+        if (this.txOver) {
+            throw new Error('tx already failed');
+        }
+        return args.node;
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}
+const noopAsync = async () => { };

package/dist/dataplane/server/db/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./db"), exports);

package/dist/dataplane/server/db/migrations/20230309T045948368Z-init.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.up = up;
+exports.down = down;
+const kysely_1 = require("kysely");
+// @TODO subject indexes, naming?
+// @TODO drop indexes in down()?
+async function up(db) {
+    try {
+        // Add trigram support, supporting user search.
+        // Explicitly add to public schema, so the extension can be seen in all schemas.
+        await (0, kysely_1.sql) `create extension if not exists pg_trgm with schema public`.execute(db);
+    }
+    catch (err) {
+        // The "if not exists" isn't bulletproof against races, and we see test suites racing to
+        // create the extension. So we can just ignore errors indicating the extension already exists.
+        if (!err?.['detail']?.includes?.('(pg_trgm) already exists'))
+            throw err;
+    }
+    // profile
+    await db.schema
+        .createTable('profile')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator_did', 'varchar', (col) => col.notNull())
+        .addColumn('display_name', 'varchar')
+        .addColumn('description', 'varchar')
+        .addColumn('avatar_cid', 'varchar')
+        .addColumn('banner_cid', 'varchar')
+        .addColumn('indexed_at', 'varchar', (col) => col.notNull())
+        .execute();
+    // follow
+    await db.schema
+        .createTable('follow')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator', 'varchar', (col) => col.notNull())
+        .addColumn('subjectDid', 'varchar', (col) => col.notNull())
+        .addColumn('createdAt', 'varchar', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('sortAt', 'varchar', (col) => col
+        .generatedAlwaysAs((0, kysely_1.sql) `least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull())
+        .addUniqueConstraint('follow_unique_subject', ['creator', 'subjectDid'])
+        .execute();
+    // for, eg, "followersCount" on profile views
+    await db.schema
+        .createIndex('follow_subjectdid_idx')
+        .on('follow')
+        .column('subjectDid')
+        .execute();
+    // like
+    await db.schema
+        .createTable('like')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('creator', 'varchar', (col) => col.notNull())
+        .addColumn('subject', 'varchar', (col) => col.notNull())
+        .addColumn('subjectCid', 'varchar', (col) => col.notNull())
+        .addColumn('createdAt', 'varchar', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('sortAt', 'varchar', (col) => col
+        .generatedAlwaysAs((0, kysely_1.sql) `least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull())
+        // Aids in index uniqueness plus post like counts
+        .addUniqueConstraint('like_unique_subject', ['subject', 'creator'])
+        .execute();
+    // subscription
+    await db.schema
+        .createTable('subscription')
+        .addColumn('service', 'varchar', (col) => col.notNull())
+        .addColumn('method', 'varchar', (col) => col.notNull())
+        .addColumn('state', 'varchar', (col) => col.notNull())
+        .addPrimaryKeyConstraint('subscription_pkey', ['service', 'method'])
+        .execute();
+    // actor
+    await db.schema
+        .createTable('actor')
+        .addColumn('did', 'varchar', (col) => col.primaryKey())
+        .addColumn('handle', 'varchar', (col) => col.unique())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .execute();
+    await db.schema // Supports user search
+        .createIndex(`actor_handle_tgrm_idx`)
+        .on('actor')
+        .using('gist')
+        .expression((0, kysely_1.sql) `"handle" gist_trgm_ops`)
+        .execute();
+    //record
+    await db.schema
+        .createTable('record')
+        .addColumn('uri', 'varchar', (col) => col.primaryKey())
+        .addColumn('cid', 'varchar', (col) => col.notNull())
+        .addColumn('did', 'varchar', (col) => col.notNull())
+        .addColumn('json', 'text', (col) => col.notNull())
+        .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+        .addColumn('takedownId', 'integer') // foreign key created in moderation-init migration
+        .execute();
+}
+async function down(db) {
+    // record
+    await db.schema.dropTable('record').execute();
+    // actor
+    await db.schema.dropTable('actor').execute();
+    // subscription
+    await db.schema.dropTable('subscription').execute();
+    // like
+    await db.schema.dropTable('like').execute();
+    // follow
+    await db.schema.dropTable('follow').execute();
+    // post
+    await db.schema.dropTable('post').execute();
+    // profile
+    await db.schema.dropTable('profile').execute();
+}

package/dist/dataplane/server/db/migrations/20230420T211446071Z-did-cache.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.up = up;
+exports.down = down;
+async function up(db) {
+    await db.schema
+        .createTable('did_cache')
+        .addColumn('did', 'varchar', (col) => col.primaryKey())
+        .addColumn('doc', 'jsonb', (col) => col.notNull())
+        .addColumn('updatedAt', 'bigint', (col) => col.notNull())
+        .execute();
+}
+async function down(db) {
+    await db.schema.dropTable('did_cache').execute();
+}

package/dist/dataplane/server/db/migrations/index.js

@@ -0,0 +1,41 @@
+"use strict";
+// NOTE this file can be edited by hand, but it is also appended to by the migration:create command.
+// It's important that every migration is exported from here with the proper name. We'd simplify
+// this with kysely's FileMigrationProvider, but it doesn't play nicely with the build process.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._20230420T211446071Z = exports._20230309T045948368Z = void 0;
+exports._20230309T045948368Z = __importStar(require("./20230309T045948368Z-init"));
+exports._20230420T211446071Z = __importStar(require("./20230420T211446071Z-did-cache"));

package/dist/dataplane/server/db/migrations/provider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtxMigrationProvider = void 0;
+// Passes a context argument to migrations. We use this to thread the dialect into migrations
+class CtxMigrationProvider {
+    constructor(migrations, ctx) {
+        Object.defineProperty(this, "migrations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: migrations
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ctx
+        });
+    }
+    async getMigrations() {
+        const ctxMigrations = {};
+        Object.entries(this.migrations).forEach(([name, migration]) => {
+            ctxMigrations[name] = {
+                up: async (db) => await migration.up(db, this.ctx),
+                down: async (db) => await migration.down?.(db, this.ctx),
+            };
+        });
+        return ctxMigrations;
+    }
+}
+exports.CtxMigrationProvider = CtxMigrationProvider;

package/dist/dataplane/server/db/pagination.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = exports.IndexedAtDidKeyset = exports.CreatedAtDidKeyset = exports.TimeCidKeyset = exports.GenericKeyset = void 0;
+const xrpc_server_1 = require("@atproto/xrpc-server");
+const kysely_1 = require("kysely");
+/**
+ * The GenericKeyset is an abstract class that sets-up the interface and partial implementation
+ * of a keyset-paginated cursor with two parts. There are three types involved:
+ *  - Result: a raw result (i.e. a row from the db) containing data that will make-up a cursor.
+ *    - E.g. { createdAt: '2022-01-01T12:00:00Z', cid: 'bafyx' }
+ *  - LabeledResult: a Result processed such that the "primary" and "secondary" parts of the cursor are labeled.
+ *    - E.g. { primary: '2022-01-01T12:00:00Z', secondary: 'bafyx' }
+ *  - Cursor: the two string parts that make-up the packed/string cursor.
+ *    - E.g. packed cursor '1641038400000__bafyx' in parts { primary: '1641038400000', secondary: 'bafyx' }
+ *
+ * These types relate as such. Implementers define the relations marked with a *:
+ *   Result -*-> LabeledResult <-*-> Cursor <--> packed/string cursor
+ *                     ↳ SQL Condition
+ */
+class GenericKeyset {
+    constructor(primary, secondary) {
+        Object.defineProperty(this, "primary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: primary
+        });
+        Object.defineProperty(this, "secondary", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: secondary
+        });
+    }
+    packFromResult(results) {
+        const result = Array.isArray(results) ? results.at(-1) : results;
+        if (!result)
+            return;
+        return this.pack(this.labelResult(result));
+    }
+    pack(labeled) {
+        if (!labeled)
+            return;
+        const cursor = this.labeledResultToCursor(labeled);
+        return this.packCursor(cursor);
+    }
+    unpack(cursorStr) {
+        const cursor = this.unpackCursor(cursorStr);
+        if (!cursor)
+            return;
+        return this.cursorToLabeledResult(cursor);
+    }
+    packCursor(cursor) {
+        if (!cursor)
+            return;
+        return `${cursor.primary}__${cursor.secondary}`;
+    }
+    unpackCursor(cursorStr) {
+        if (!cursorStr)
+            return;
+        const result = cursorStr.split('__');
+        const [primary, secondary, ...others] = result;
+        if (!primary || !secondary || others.length > 0) {
+            throw new xrpc_server_1.InvalidRequestError('Malformed cursor');
+        }
+        return {
+            primary,
+            secondary,
+        };
+    }
+    getSql(labeled, direction, tryIndex) {
+        if (labeled === undefined)
+            return;
+        if (tryIndex) {
+            // The tryIndex param will likely disappear and become the default implementation: here for now for gradual rollout query-by-query.
+            if (direction === 'asc') {
+                return (0, kysely_1.sql) `((${this.primary}, ${this.secondary}) > (${labeled.primary}, ${labeled.secondary}))`;
+            }
+            else {
+                return (0, kysely_1.sql) `((${this.primary}, ${this.secondary}) < (${labeled.primary}, ${labeled.secondary}))`;
+            }
+        }
+        else {
+            // @NOTE this implementation can struggle to use an index on (primary, secondary) for pagination due to the "or" usage.
+            if (direction === 'asc') {
+                return (0, kysely_1.sql) `((${this.primary} > ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} > ${labeled.secondary}))`;
+            }
+            else {
+                return (0, kysely_1.sql) `((${this.primary} < ${labeled.primary}) or (${this.primary} = ${labeled.primary} and ${this.secondary} < ${labeled.secondary}))`;
+            }
+        }
+    }
+}
+exports.GenericKeyset = GenericKeyset;
+class TimeCidKeyset extends GenericKeyset {
+    labelResult(result) {
+        return { primary: result.sortAt, secondary: result.cid };
+    }
+    labeledResultToCursor(labeled) {
+        return {
+            primary: new Date(labeled.primary).getTime().toString(),
+            secondary: labeled.secondary,
+        };
+    }
+    cursorToLabeledResult(cursor) {
+        const primaryDate = new Date(parseInt(cursor.primary, 10));
+        if (isNaN(primaryDate.getTime())) {
+            throw new xrpc_server_1.InvalidRequestError('Malformed cursor');
+        }
+        return {
+            primary: primaryDate.toISOString(),
+            secondary: cursor.secondary,
+        };
+    }
+}
+exports.TimeCidKeyset = TimeCidKeyset;
+class CreatedAtDidKeyset extends TimeCidKeyset {
+    labelResult(result) {
+        return { primary: result.createdAt, secondary: result.did };
+    }
+}
+exports.CreatedAtDidKeyset = CreatedAtDidKeyset;
+class IndexedAtDidKeyset extends TimeCidKeyset {
+    labelResult(result) {
+        return { primary: result.indexedAt, secondary: result.did };
+    }
+}
+exports.IndexedAtDidKeyset = IndexedAtDidKeyset;
+const paginate = (qb, opts) => {
+    const { limit, cursor, keyset, direction = 'desc', tryIndex, nullsLast, } = opts;
+    const keysetSql = keyset.getSql(keyset.unpack(cursor), direction, tryIndex);
+    return qb
+        .if(!!limit, (q) => q.limit(limit))
+        .if(!nullsLast, (q) => q.orderBy(keyset.primary, direction).orderBy(keyset.secondary, direction))
+        .if(!!nullsLast, (q) => q
+        .orderBy(direction === 'asc'
+        ? (0, kysely_1.sql) `${keyset.primary} asc nulls last`
+        : (0, kysely_1.sql) `${keyset.primary} desc nulls last`)
+        .orderBy(direction === 'asc'
+        ? (0, kysely_1.sql) `${keyset.secondary} asc nulls last`
+        : (0, kysely_1.sql) `${keyset.secondary} desc nulls last`))
+        .if(!!keysetSql, (qb) => (keysetSql ? qb.where(keysetSql) : qb));
+};
+exports.paginate = paginate;

package/dist/dataplane/server/db/tables/actor-sync.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'actor_sync';

package/dist/dataplane/server/db/tables/actor.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'actor';

package/dist/dataplane/server/db/tables/artist-list-item.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist_list_item';

package/dist/dataplane/server/db/tables/artist.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'artist';

package/dist/dataplane/server/db/tables/playlist-idea.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_idea';

package/dist/dataplane/server/db/tables/playlist-item.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist_item';

package/dist/dataplane/server/db/tables/playlist.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'playlist';

package/dist/dataplane/server/db/tables/profile.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'profile';

package/dist/dataplane/server/db/tables/record.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'record';

package/dist/dataplane/server/db/tables/song.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableName = void 0;
+exports.tableName = 'song';

package/dist/dataplane/server/db/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });